AI Fitness Product Photography API — Gear and Flavor Variants
A supplement brand launching a protein powder in five flavors has one professional studio shot of the tub — chocolate, front label, white background — and the e-commerce team needs matching shots for vanilla, strawberry, cookies-and-cream, and unflavored before the listing goes live next week. Rebooking the same studio, lighting rig, and photographer for four more flavor variants of an otherwise identical tub costs more than most fitness brands budget for a single SKU launch, and the shoot backlog means the listing goes live with a placeholder image on four of five variants during the exact week paid traffic starts pointing at the product page.
Direct answer: a reference-guided image generation API takes the existing tub photo as image input plus a prompt describing the label color and flavor name change, and returns a new image that holds the tub shape, lighting, and background consistent while altering only the label artwork — no second studio session required.
How Does an API Generate Flavor and Color Variants From One Shoot?
Reference-guided generation anchors the output to the product's fixed geometry — tub shape, cap style, label placement, shadow direction — then applies the label color and text change described in the prompt. This differs from text-to-image generation, which has no source product to match and would produce a plausible-looking supplement tub rather than the exact SKU on the shelf, a real risk in fitness retail where a mismatched tub shape between the listing photo and the product that arrives drives return requests.
Fitness gear photography carries the same pattern for non-consumable products: a resistance band, yoga mat, or shaker bottle shot once in a neutral colorway can be re-rendered in each catalog color without re-shooting the physical object, as long as the prompt names the exact color change and leaves material texture (matte rubber, woven fabric) unstated so the model carries it over from the reference.
Which Model Fits Fitness Product Photography?
Nano Banana Pro's reference-guided mode holds label placement, tub shape, and studio lighting consistent across flavor and color changes, which matters for supplement photography because a shifted label or warped cap reads as a stock-photo mismatch to a shopper comparing the listing image against the product that ships. GPT-image-2 fits smaller instruction-based touch-ups — a nutrition-panel update, a seal-badge addition, or a background color swap — on a shot that's otherwise already final.
| Model | Mode | Resolution / price | Shape consistency | Best for |
|---|---|---|---|---|
| Nano Banana Pro | Reference-guided | 1K $0.030 / 2K $0.030 / 4K $0.042 | High | Full flavor or colorway variant sets from one base shoot |
| Nano Banana 2 | Reference-guided | 1K $0.020 / 4K $0.036 | Medium-high | Lower-cost variant drafts for internal marketing review |
| GPT-image-2 | Instruction-based edit | $0.014/image | N/A (edits existing photo) | Nutrition-panel update, badge add, or background swap |
For a listing-facing flavor launch, Nano Banana Pro's consistency at 2K resolution is worth the small premium over Nano Banana 2 — a warped tub or shifted label reads as a defect to a shopper zooming in on the product photo before checkout, not a rendering quirk.
How Do I Generate a Flavor Variant via API?
Submit the base product photo as image input with a prompt describing the target label color and flavor name; the endpoint returns a job ID to poll for the finished image.
import requests, time
API_KEY = "YOUR_KEY"
BASE = "https://genrelay.ai/v1"
def generate_variant(reference_url, flavor_name, label_color):
r = requests.post(
f"{BASE}/images/generations",
headers={"Authorization": f"Bearer {API_KEY}"},
json={
"model": "nano-banana-pro",
"prompt": f"same tub shape, cap, lighting, and background, "
f"label recolored to {label_color} with '{flavor_name}' text, "
f"professional product photography, white background",
"image": reference_url,
"resolution": "2k",
},
)
return r.json()["id"]
job_id = generate_variant(
"https://cdn.example.com/products/protein-tub-chocolate.jpg",
"Strawberry",
"pink",
)
Poll the job until it completes, since reference-guided generation is asynchronous:
def wait_for_result(job_id, timeout=90):
start = time.time()
while time.time() - start < timeout:
status = requests.get(
f"{BASE}/images/generations/{job_id}",
headers={"Authorization": f"Bearer {API_KEY}"},
).json()
if status["status"] == "completed":
return status["output_url"]
if status["status"] == "failed":
raise RuntimeError(status.get("error"))
time.sleep(2)
raise TimeoutError(f"Job {job_id} did not finish in {timeout}s")
image_url = wait_for_result(job_id)
How Do I Batch a Full Flavor Lineup?
Loop over the flavor and color list and submit each as its own job, holding concurrency low enough to stay under the account's rate limit — see the batch image generation guide for the concurrency and retry pattern this scales to.
from concurrent.futures import ThreadPoolExecutor
FLAVORS = [
("Vanilla", "cream"),
("Strawberry", "pink"),
("Cookies & Cream", "dark gray with white flecks graphic"),
("Unflavored", "white"),
]
def generate_and_wait(entry):
flavor_name, label_color = entry
job_id = generate_variant(
"https://cdn.example.com/products/protein-tub-chocolate.jpg",
flavor_name,
label_color,
)
return flavor_name, wait_for_result(job_id)
with ThreadPoolExecutor(max_workers=3) as pool:
results = list(pool.map(generate_and_wait, FLAVORS))
for flavor_name, url in results:
print(f"{flavor_name}: {url}")
What Does a Full Launch Cost?
A five-flavor launch at 2K resolution via Nano Banana Pro costs 5 × $0.030 = $0.15 for the full set, including the original flavor re-rendered at the same resolution for a consistent catalog. Adding a 4K hero shot of the lead flavor for the homepage banner adds $0.042, bringing the combined total to $0.192.
| Package tier | Composition | Cost |
|---|---|---|
| Full flavor set (Nano Banana Pro, 2K) | 5 × $0.030 | $0.15 |
| Hero shot upgrade (Nano Banana Pro, 4K) | 1 × $0.042 | $0.042 |
| Combined launch set | Both above | $0.192 |
| Lower-cost draft pass (Nano Banana 2, 1K) | 5 × $0.020 | $0.10 |
At under $0.20 for a complete five-flavor listing set with a 4K hero shot included, generating every variant from one studio session costs less than the shipping fee on a single reshoot sample, without rebooking a studio around a launch calendar. See the AI video generation API for fitness and wellness brands guide for turning the same base shots into showcase clips.
Internal Links
- Nano Banana Pro and Nano Banana 2 on GenRelay
- AI video generation API for fitness and wellness brands
- AI apparel photography API
FAQ
Does reference-guided generation work on gear like resistance bands or yoga mats, not just supplement tubs?
Yes — the same pattern applies to any product with fixed geometry and a changing color or print; the prompt should name the exact color or pattern change and leave material texture unstated so the model carries it over from the reference photo.
Why does the tub shape sometimes drift on a cheaper model?
Lower-tier reference-guided models hold overall product identity but are less precise on fine geometry like cap threading or label curvature at the edges — Nano Banana Pro's higher consistency is the reason it costs more per image than Nano Banana 2.
Can I update the nutrition panel text without regenerating the whole image?
Yes — GPT-image-2's instruction-based editing mode is built for exactly this: a text or small-element change on an otherwise final photo, rather than a full reference-guided re-render.
Do I need a different prompt for matte versus glossy packaging?
Only if the finish itself is changing. If the reference photo already shows the matte or glossy finish and only color changes, leaving finish unstated lets the model carry it over; state it explicitly only when the variant also changes the material finish.