AI Image Generation API With No Watermark — Clean Output for Production Apps

You've built an AI image generator into your SaaS product. Testing looks great — then a user screenshots the output and emails you: "Why is there a logo in the corner?" You're using a consumer image tool's web interface, not a developer API. The watermark is the provider's signal to upgrade.

Production image generation APIs don't work this way. When you call an image API with a valid key, you receive the model's raw output: clean pixel data, no overlays, no branding. This article explains which APIs produce watermark-free output, how to integrate them, and how to verify what you receive.

Do AI image generation APIs watermark their output?

No — production developer APIs do not watermark output images. Watermarks are a consumer product mechanism, applied in web interfaces to signal that a paying tier unlocks clean downloads. API access sidesteps this entirely.

The distinction matters for integration:

• Consumer apps (Midjourney web UI, free Adobe Firefly, free Canva AI): output watermarked on free tiers, clean on paid subscriptions, no programmatic access via REST API.
• Developer APIs (GenRelay with Nano Banana Pro, Nano Banana 2, GPT-image-2): output is always the raw model response, watermark-free, accessible via POST request with a Bearer token.

GenRelay's image models — Nano Banana Pro, Nano Banana 2, and GPT-image-2 — return clean output regardless of plan tier. Free credits work identically to paid credits: same API, same endpoint, same image bytes.

What image models are available on GenRelay, and what do they cost?

As of August 2026, GenRelay offers three image generation models:

Model	Supported resolutions	Output strength	Price
Nano Banana Pro	1K · 2K · 4K	Photorealism, high prompt accuracy	$0.030/image (1K, 2K) · $0.042 (4K)
Nano Banana 2	1K · 4K	Fast generation, cost-efficient	$0.020/image (1K) · $0.036 (4K)
GPT-image-2	Standard	Instruction following, image editing	$0.014/image

All three return images as a URL pointing to a PNG or JPEG file. No watermarks, no visible branding, no binary modification of the pixel data beyond what the model produced.

Nano Banana Pro delivers the highest-fidelity output of the three. It handles detailed prompts reliably at 4K resolution, making it a practical choice for product photography automation, UI asset generation, and any context where images appear at large display sizes.

Nano Banana 2 runs at roughly 60% of the cost of Nano Banana Pro at 1K resolution. For high-volume workflows — generating hundreds of images per day for catalog pipelines or social media — the per-image cost difference compounds quickly. At 1K, Nano Banana 2 costs $0.020 versus Nano Banana Pro's $0.030: a 33% saving per call.

GPT-image-2 is the model to use when you need to modify an existing image from a text instruction. Unlike the other two, it supports image editing: pass a base image and a prompt like "change the background to white studio", and the model returns a modified version. At $0.014 per image, it is also the most affordable option for straightforward generation tasks.

How do I generate a watermark-free image via the GenRelay API?

Here is a working Python example using Nano Banana Pro:

import requests

response = requests.post(
    "https://genrelay.ai/v1/images/generations",
    headers={"Authorization": "Bearer YOUR_GENRELAY_KEY"},
    json={
        "model": "nano-banana-pro",
        "prompt": "Product photo of a white ceramic mug on a marble surface, soft natural light, no shadows",
        "size": "1024x1024"
    }
)

data = response.json()
image_url = data["data"][0]["url"]
print(f"Image ready: {image_url}")

The URL points to a clean PNG file, available for 24 hours. To save it locally and confirm there is no watermark layer:

import requests

# Generate the image
gen = requests.post(
    "https://genrelay.ai/v1/images/generations",
    headers={"Authorization": "Bearer YOUR_GENRELAY_KEY"},
    json={
        "model": "nano-banana-pro",
        "prompt": "Product photo of a white ceramic mug on a marble surface, soft natural light",
        "size": "2048x2048"
    }
)

image_url = gen.json()["data"][0]["url"]

# Download
img = requests.get(image_url)
with open("product_mug.png", "wb") as f:
    f.write(img.content)

print(f"Saved {len(img.content)} bytes — open in any image editor to verify no overlay")

The saved file is a standard PNG with no watermark layer and no overlay pixels. You can inspect it in Photoshop, GIMP, or any image analysis tool — the layer count will be one.

How do I switch models without rewriting my integration?

The GenRelay endpoint is identical for all three image models — you change the model parameter only:

import requests

def generate_image(prompt: str, model: str = "nano-banana-pro", size: str = "1024x1024") -> str:
    resp = requests.post(
        "https://genrelay.ai/v1/images/generations",
        headers={"Authorization": "Bearer YOUR_GENRELAY_KEY"},
        json={"model": model, "prompt": prompt, "size": size}
    )
    resp.raise_for_status()
    return resp.json()["data"][0]["url"]

# Route between models based on budget or use case
url_pro = generate_image("A mountain landscape at golden hour", model="nano-banana-pro")
url_v2  = generate_image("A mountain landscape at golden hour", model="nano-banana-2")
url_gpt = generate_image("A mountain landscape at golden hour", model="gpt-image-2")

This lets you A/B test model output quality or route by cost constraint — without maintaining separate API clients or auth flows for each model. For a detailed cost breakdown across resolution tiers, see AI image generation API pricing comparison.

What about invisible watermarks or C2PA metadata?

C2PA (Coalition for Content Provenance and Authenticity) is a metadata standard — not a visible watermark — that some AI providers embed in model output to signal AI provenance. It is stored in the file's metadata fields, not in the pixel data, and has no visual effect whatsoever.

As of August 2026:

• GPT-image-2: may embed C2PA content credentials in the image file's metadata.
• Nano Banana Pro / Nano Banana 2: no C2PA data embedded.

C2PA metadata does not affect image quality, display rendering, or commercial use. If your pipeline requires clean metadata — for example, a creative asset system that enforces strict EXIF control — strip metadata after download using piexif in Python or exiftool in shell.

What if a generated image has unexpected artifacts?

Artifacts in AI-generated images (color banding, anatomical errors, repeated texture patches) are model output characteristics, not watermarks. They result from prompt ambiguity, resolution mismatches, or the model's inherent limitations for a given subject.

Approaches to reduce artifacts:

• Increase specificity in the prompt: "studio lighting, white background, single object" outperforms "nice photo".
• Switch resolution tiers: 2K often produces cleaner composition than 1K at the cost of $0.030 vs $0.020 (for Nano Banana Pro).
• Switch models: Nano Banana Pro handles complex prompts more reliably than Nano Banana 2 in exchange for higher cost.
• Submit the prompt and model to GenRelay support if artifacts appear consistently regardless of prompt variation.

FAQ

Do free credits produce watermarked images?
No. GenRelay's free credits use the same API endpoint and produce the same clean output as paid usage. Watermarks do not appear at any credit tier.

What formats does the API return?
Images are returned as URLs pointing to PNG files by default. Most endpoints also support response_format: "b64_json" if you need base64-encoded bytes without a separate HTTP download.

Is the output licensed for commercial use?
As of August 2026, all three image models on GenRelay permit commercial use of generated images. You own the output generated through your API key.

Does GenRelay resize or compress images before returning them?
No. The API returns the image at the resolution you requested. There is no server-side downscaling or quality reduction applied to the output.

What if I need to prove the output is watermark-free to a client?
Open the returned image in an image editor and inspect the layer structure. One layer with no overlays confirms clean output. You can also use exiftool -all= -overwrite_original file.png to strip any metadata and deliver provably clean pixel data.