AI Watch Photography API — Dial, Strap, and Case Finish Variants
A watch brand has one finished studio shot of its new model — silver case, black leather strap, white dial catching the light at the usual 45-degree angle — and the catalog launch calls for a navy dial version, a steel-bracelet option, and a limited black-PVD case finish, all before a second case has come back from the plating shop. Booking a product photographer for every dial color, strap material, and case finish combination costs more than most watch brands budget for a single drop, and a limited PVD run often sells out before a reshoot could even get scheduled. Generating the dial, strap, and case variants from the one watch already photographed answers "what does the navy dial actually look like on wrist" without plating a single test case.
Direct answer: a reference-guided image generation API takes the existing studio watch photo as input plus a prompt describing the new dial color, strap material, or case finish, and returns a new image that holds the case shape, lug width, and crown placement fixed while changing only the described detail — no reshoot per variant, no waiting on a plating or strap-sourcing run.
How Does an API Generate Watch Dial and Strap Variants From One Studio Photo?
Reference-guided generation anchors the output to the watch's fixed geometry — case diameter, lug width, crown and pusher placement, hand shape — then renders the described dial color, strap material, or case finish change around that fixed shape. This differs from plain text-to-image generation, which has no source watch to match and produces a plausible-looking timepiece rather than the exact model shipping to the customer, a real risk when a product page photo needs to match what actually arrives on someone's wrist.
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 dial, strap, and case finish 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 second hand, swap a buckle) | $0.014/image | $0.014/image | Yes, instruction-driven |
Nano Banana Pro holds a case's lug width and crown placement most reliably across a full dial-and-strap change, which matters when a steel bracelet needs to catch studio light differently than the original leather strap while still reading as the same case. GPT-image-2 fits small, targeted edits — recoloring a second hand or swapping a buckle finish — better than a full dial-and-strap restyle.
How Do I Call the API to Generate a Dial Variant?
Authenticate with a bearer token and send the source photo plus a prompt describing the dial or strap change. Here's a minimal working request using Nano Banana Pro:
import requests
API_KEY = "YOUR_KEY"
BASE = "https://genrelay.ai/v1"
with open("watch_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 watch case, same diameter and lug width, "
"dial recolored to deep navy with silver indices, "
"leather strap swapped to a brushed steel bracelet, "
"studio lighting unchanged."
),
"resolution": "2k",
},
)
job = r.json()
image_url = job["data"][0]["url"]
For a full dial-and-strap lineup, batch the same reference image against a list of prompts rather than calling the endpoint one at a time:
import concurrent.futures
variants = [
"dial recolored to deep navy, same case and strap",
"steel bracelet swap, white dial unchanged",
"black PVD case finish, black dial, black NATO strap",
]
def generate(prompt):
with open("watch_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 Dial and Strap Launch Cost?
Cost scales with resolution and image count, not with how different each variant looks from the studio original. A watch brand launching 3 dial-color variants from one case 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 dial-and-strap variant across 6 SKUs — 6 images — costs $0.18 at 2K.
| Scope | Images | Model/resolution | Total cost |
|---|---|---|---|
| Single case, 3 dial-color variants | 3 | Nano Banana Pro, 2K | $0.09 |
| Same set, print-quality catalog | 3 | Nano Banana Pro, 4K | $0.126 |
| 6 SKUs × seasonal dial/strap variant | 6 | Nano Banana Pro, 2K | $0.18 |
| 6 SKUs, instruction-only buckle recolor | 6 | GPT-image-2 | $0.084 |
At this price point, generating a full seasonal dial-and-strap lineup costs less than the shipping label for a single sample case, which is why most watch brands generate the variants first and reserve an actual plating or strap-sourcing run for the colorways that pre-sell well enough to justify it.
How Do I Keep the Watch Recognizable Across Variants?
Keep every prompt change scoped to the dial color, strap material, or case finish, never the case diameter, lug width, or crown placement, since those are exactly the elements reference-guided generation is designed to hold fixed. If a variant starts drifting (the case gets larger, the lugs reshape), the fix is almost always a prompt that's too aggressive about "reimagining" the product rather than recoloring it; rephrase toward "same case, same diameter and lug width, change only the dial, strap, and case finish."
FAQ
Does the API support video, not just photos, for watch product showcases?
Yes — GenRelay's video models (Veo 3.1 Lite, Grok Imagine) can turn a still watch photo into a short rotating, clasping, or crown-winding clip. See the wallet and leather goods video API guide for a related accessory-category pricing and code walkthrough.
Can I edit a specific detail instead of restyling the whole watch?
Yes — GPT-image-2 handles instruction-based edits like "recolor the second hand" or "swap the buckle finish" at $0.014 per image, cheaper than a full Nano Banana Pro restyle when the change is small.
Will the generated dial variant 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.