AI Luggage and Travel Gear Photography API — Color and Material Variants
A travel gear brand has one finished studio photo of its carry-on — matte navy shell, polished aluminum corner guards, handle extended — and the next catalog drop calls for a sand-colored version, a glossy finish option, and a limited rose-gold hardware variant, all before a single additional shell has come off the injection mold. Booking a product photographer for every shell color, material finish, and hardware combination costs more than most travel gear brands budget for a seasonal refresh, and a limited hardware run often sells through before a reshoot could even get scheduled. Generating the color and finish variants from the one carry-on already photographed answers "what does the sand colorway actually look like on the shelf" without ordering a single test shell.
Direct answer: a reference-guided image generation API takes the existing studio luggage photo as input plus a prompt describing the new shell color, material finish, or hardware swap, and returns a new image that holds the case's shape, proportions, and wheel placement fixed while changing only the described detail — no reshoot per colorway, no waiting on an injection-mold run.
How Does an API Generate Luggage Color Variants From One Studio Photo?
Reference-guided generation anchors the output to the product's fixed geometry — a hardshell case's corner radius, a wheel housing's position, a handle's telescoping mechanism — then renders the described shell color, material finish, or hardware change around that fixed shape. This differs from plain text-to-image generation, which has no source case to match and produces a plausible-looking suitcase rather than the exact shell shipping to the customer, a real risk when a product page photo needs to match what actually arrives at someone's door.
As of October 2026, GenRelay exposes three image models through one endpoint for this workflow:
| Model | Best for | 1K price | 4K price | Editing support |
|---|---|---|---|---|
| Nano Banana Pro | Reference-guided shell color, finish, and hardware swaps | $0.030 | $0.042 | Yes, strong consistency |
| Nano Banana 2 | Faster batch variants, slightly lower consistency | $0.020 | $0.036 | Yes |
| GPT-image-2 | Instruction-based edits (recolor a zipper pull, swap a logo patch) | $0.014/image | $0.014/image | Yes, instruction-driven |
Nano Banana Pro holds a hardshell case's corner radius and wheel housing most reliably across a full color-and-finish change, which matters when a glossy variant needs to catch studio light differently than the original matte shell while still reading as the same case. GPT-image-2 fits small, targeted edits — recoloring a zipper pull or swapping a logo patch — better than a full shell restyle.
How Do I Call the API to Generate a Color Variant?
Authenticate with a bearer token and send the source photo plus a prompt describing the shell change. Here's a minimal working request using Nano Banana Pro:
import requests
API_KEY = "YOUR_KEY"
BASE = "https://genrelay.ai/v1"
with open("carryon_studio.jpg", "rb") as f:
r = requests.post(
f"{BASE}/images/generations",
headers={"Authorization": f"Bearer {API_KEY}"},
files={"reference_image": f},
data={
"model": "nano-banana-pro",
"prompt": (
"Same carry-on case, same shape and corner radius, "
"shell recolored to matte sand, aluminum corner guards "
"swapped to brushed rose gold, studio lighting "
"unchanged."
),
"resolution": "2k",
},
)
job = r.json()
image_url = job["data"][0]["url"]
For a full colorway lineup, batch the same reference image against a list of prompts rather than calling the endpoint one at a time:
import concurrent.futures
variants = [
"shell recolored to matte sand, same hardware",
"glossy charcoal finish, same shape and proportions",
"matte navy shell, rose-gold corner guards and zipper pulls",
]
def generate(prompt):
with open("carryon_studio.jpg", "rb") as f:
r = requests.post(
f"{BASE}/images/generations",
headers={"Authorization": f"Bearer {API_KEY}"},
files={"reference_image": f},
data={"model": "nano-banana-pro", "prompt": prompt, "resolution": "2k"},
)
return r.json()["data"][0]["url"]
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as pool:
results = list(pool.map(generate, variants))
Both calls are synchronous — image generation returns a URL directly in the response rather than requiring a polling loop, unlike video generation jobs.
What Does a Full Colorway Launch Cost?
Cost scales with resolution and image count, not with how different each colorway looks from the studio original. A travel gear brand launching 3 shell-color variants from one carry-on photo — 3 images — at Nano Banana Pro's 2K price of $0.030 per image costs $0.09 for the full set. Running the same 3 images at 4K for print catalog use costs $0.126 at $0.042 per image. A brand generating a color-and-hardware variant across 6 SKUs — 6 images — costs $0.18 at 2K.
| Scope | Images | Model/resolution | Total cost |
|---|---|---|---|
| Single case, 3 color variants | 3 | Nano Banana Pro, 2K | $0.09 |
| Same set, print-quality catalog | 3 | Nano Banana Pro, 4K | $0.126 |
| 6 SKUs × seasonal color/hardware variant | 6 | Nano Banana Pro, 2K | $0.18 |
| 6 SKUs, instruction-only hardware recolor | 6 | GPT-image-2 | $0.084 |
At this price point, generating a full seasonal colorway lineup costs less than the shipping label for a single sample unit, which is why most travel gear brands generate the color variants first and reserve an actual injection-mold run for the colorways that pre-sell well enough to justify it.
How Do I Keep the Case Recognizable Across Variants?
Keep every prompt change scoped to the shell color, material finish, or hardware, never the case's corner radius, wheel housing position, or handle mechanism, since those are exactly the elements reference-guided generation is designed to hold fixed. If a variant starts drifting (the case gets rounder, the wheels move), the fix is almost always a prompt that's too aggressive about "reimagining" the product rather than recoloring it; rephrase toward "same case, same shape and proportions, change only the shell color, finish, and hardware."
FAQ
Does the API support video, not just photos, for luggage product showcases?
Yes — GenRelay's video models (Veo 3.1 Lite, Grok Imagine) can turn a still case photo into a short rolling, unzipping, or rotating clip. See the luggage and travel gear video API guide for pricing and code.
Can I edit a specific detail instead of restyling the whole case?
Yes — GPT-image-2 handles instruction-based edits like "recolor the zipper pull" or "swap the logo patch" at $0.014 per image, cheaper than a full Nano Banana Pro restyle when the change is small.
Will the generated colorway pass as the real product to a customer comparing it to the one they receive?
It should match the real shape and proportions closely enough for marketing use, but disclose AI-generated marketing images per your local advertising rules — this is a legal, not technical, requirement.
What image formats does the API accept as a reference?
JPEG and PNG, up to 10MB. Larger source files should be downsized before upload; resolution of the output is controlled by the resolution parameter, not the input file size.
Is there a rate limit on reference-guided generation calls?
Yes, scoped per API key — check response headers for your current limit, and use a thread pool with a small max_workers count (3–5) for batch jobs rather than firing all requests simultaneously.
Explore the Nano Banana Pro model page for full parameter docs, or read the visual consistency guide for more on reference-guided generation across a product line.