GPT Image 2.6 API: GIF, SVG and $0.03 VIP

​

Choose a route

• You pick the token group when you create the token; it never goes in the request:
  • Official forwarding uses OpenAI Official or OpenAI Official Enterprise with the Usage first or Usage-based billing mode.
  • The VIP and web routes use default or another image group with the Usage first or Per-call billing mode.
• All three routes use /v1/images/generations to generate and /v1/images/edits to edit, with the same request format as the OpenAI Images API.
• Which to use: official forwarding for SVG, GIFs straight from an edit, or the fastest images; VIP for native 4K PNGs at a fixed price; the web route for GIFs at a fixed price (1024×1024 and up).

​

What changed from GPT Image 2.5

• New output formats: official forwarding returns animated GIFs and SVG vector images, and the web route returns GIFs.
• A new complexity parameter (low, medium, high) sets how busy the image is, at no extra charge.
• Via official forwarding, low and medium use 3–4 times the tokens of 2.5, while high and above cost the same; for large batches of drafts, GPT Image 2.5 stays cheaper.
• The 2.6 VIP models don’t accept xhigh or max; for those tiers at a fixed price, keep using 2.5 VIP.

​

Before you call

export LAOZHANG_API_KEY="your LaoZhang API key"
export BASE_URL="https://api.laozhang.ai/v1"

import base64
import json
import sys
import urllib.request
from pathlib import Path

if len(sys.argv) != 3:
    raise SystemExit("usage: python save_images.py response.json output_prefix")


def decode_b64(value):
    # Strip a data:...;base64, prefix if present and restore missing = padding
    if value.startswith("data:"):
        value = value.split(",", 1)[1]
    value = "".join(value.split())
    value += "=" * (-len(value) % 4)
    return base64.b64decode(value, validate=True)


def extension_of(raw):
    # Detect the format from the file header: PNG, JPEG, WebP, GIF, or SVG
    if raw.startswith(b"\x89PNG"):
        return "png"
    if raw.startswith(b"\xff\xd8"):
        return "jpg"
    if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP":
        return "webp"
    if raw.startswith(b"GIF8"):
        return "gif"
    if b"<svg" in raw[:2048]:
        return "svg"
    raise RuntimeError("Unrecognized image format")


payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
if payload.get("error"):
    raise RuntimeError(payload["error"])
items = payload.get("data") or []
if not items:
    raise RuntimeError("No image in the response; check the error message and call logs")

for index, item in enumerate(items, start=1):
    if item.get("b64_json"):
        raw = decode_b64(item["b64_json"])
    elif item.get("url"):
        with urllib.request.urlopen(item["url"], timeout=60) as download:
            raw = download.read()
    else:
        raise RuntimeError(f"Item {index} has neither image data nor a URL")
    output = Path(f"{sys.argv[2]}-{index}.{extension_of(raw)}")
    output.write_bytes(raw)
    print(f"Saved {output} ({len(raw)} bytes)")

​

GPT Image 2.6 via official forwarding

• From high up, 2.6 costs the same as 2.5. At low and medium it uses 3–4 times the tokens, so 2.5 stays cheaper for large batches of drafts.
• Landscape 1536×1024 uses fewer tokens: 664 at low, 1,353 at high.
• Native 4K (3840×2160) at high uses about 3,337 tokens, about $0.10.
• Always send quality. Without it, Flare picks a level from the prompt, and a detailed prompt can use about 5,800 tokens for one 1024 image. Sunburst defaults to high.

curl --fail-with-body "$BASE_URL/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-flare",
    "prompt": "An orange cat stretches on a windowsill, then yawns while light rain falls outside, flat illustration style, looping animation",
    "output_format": "gif",
    "size": "512x512",
    "frame_count": 9,
    "frame_duration_ms": 200,
    "quality": "medium"
  }' -o gif.json

• frame_count defaults to 9 frames. frame_duration_ms defaults to 200 and must be at least 20.
• All frames are rendered on one sheet, so a small size with many frames fails with No supported sheet fits. 512x512 with 4–9 frames works as is; nine frames at medium use about 2,073 tokens (about $0.06).
• stream is not supported.

​

Generate SVG vector images

curl --fail-with-body "$BASE_URL/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-flare",
    "prompt": "A flat coffee cup icon with rising steam and a green leaf on the cup, warm brown and cream colors",
    "output_format": "svg",
    "quality": "medium",
    "size": "1024x1024"
  }' -o svg.json

• svg.model picks the text model that writes the SVG. Leave it out to use gpt-6.1-terra.
• To choose another, send for example "svg": {"model": "gpt-5.5"} (gpt-5.5 adds a writing charge; see billing below). It must be a text model; an image model returns model_not_found.

• Reference image: billed from usage at the official rate, like any other image.
• SVG writing is free with the default gpt-6.1-terra and with eight low-cost text models:
  • gpt-5.4-mini, gpt-5.4-nano, gpt-5-mini, gpt-5-nano
  • gpt-4.1-mini, gpt-4o-mini, gpt-5.6-luna, gpt-6-luna
• Any other writing model, such as gpt-5.5 or gpt-6-sol, is billed at its official rate and reported in svg_usage. Usage logs convert that cost at equal value into text input tokens, shown in svg_usage.billed_as_text_input_tokens; with a free model the value is 0.

• Supported writing models: GPT text models such as GPT-5.x, GPT-6.x, GPT-4.1, GPT-4o and o3. Others return unsupported_svg_model, with no charge.
• Optional svg.reasoning.effort (low, medium, high and so on) sets how much the model thinks while writing. High measured 2.6–14 times the default’s tokens; the default is enough for icons.
• Busier pictures mean longer SVG code, higher cost and longer waits.
• Detailed full scenes, such as a whole coffee-shop interior, mostly failed in our tests, each after 2–3 minutes. Use SVG for icons, logos and simple graphics.
• Only /v1/images/generations supports SVG. Edits and stream are not supported, and n must be 1.
• When OpenAI returns a 502, the gateway retries or switches to another route. If every attempt fails, you get an error, usually svg_generation_failed, with no charge and no reference image. Retry later or simplify the prompt.

​

GPT Image 2.6 VIP per image

export LAOZHANG_API_KEY="YOUR_DEFAULT_GROUP_KEY"

curl --fail-with-body "https://api.laozhang.ai/v1/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-flare-vip",
    "prompt": "A product photo of a white ceramic mug on a gray desk in soft natural light",
    "size": "2048x2048",
    "quality": "high"
  }' \
  -o generation.json

python3 save_images.py generation.json generation

• 2.6 official forwarding: a high 1024×1024 image costs about $0.053 there, against $0.03 on VIP. Use it for GIF, SVG, or faster output (Flare takes 8–12 s).
• 2.5 VIP: also $0.03 per image, with xhigh and max. Stay on 2.5 VIP when you need those tiers.
• 2.6 web route: also $0.03 per call and faster (usually 20–35 s), returns animated GIFs. It renders natively at up to about 2K and upscales 4K, so use it when 1K or 2K is enough; see GPT Image 2.6 web route.

​

GPT Image 2.6 web route

export LAOZHANG_API_KEY="YOUR_DEFAULT_GROUP_KEY"

curl --fail-with-body "https://api.laozhang.ai/v1/images/generations" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-web",
    "prompt": "A cute orange cat sitting and waving at the camera, flat cartoon style, plain light blue background, seamless loop",
    "size": "1024x1024",
    "output_format": "gif",
    "frame_count": 8,
    "frame_duration_ms": 120
  }' \
  -o gif.json

• frame_count is 2–64 (default 9); frame_duration_ms is 20–2000 (default 200).
• Always pass size. Without it, the GIF comes back small and oddly sized (for example 439×390). 1024x1024 is a good default.
• n must be 1.
• stream: true doesn’t stream: the whole GIF arrives once it’s done.
• More frames take longer and make bigger files. At 1024×1024: 4–9 frames about 35–42 s and 1–2.5 MB; 16 frames about 100 s and about 5 MB; 64 frames about 2 min and about 18 MB, with softer frames. 2048×2048 with 9 frames takes about 54 s and is about 11 MB. Set your client timeout to at least 300 s.
• At busy times, large or many-frame GIFs can return 429 after about 2 minutes, with no charge. Retry later, or use fewer frames or a smaller size.

• 2.6 web route: 1024×1024 or larger, flat $0.03 per call, frame control.
• 2.6 official forwarding: small GIFs such as 512x512, GIFs straight from an edit, or SVG. Billed by tokens; 512×512 with 9 frames at medium is about $0.06. See GPT Image 2.6 via official forwarding.
• 2.6 VIP: no GIFs; use it for native 4K PNGs.

​

Frequently asked questions

​

Can I call GPT Image 2.6 without an OpenAI account?

​

How much does the GPT Image 2.6 API cost per image?

​

Related documentation

• GPT Image 2.5 API: the previous model, whose VIP route supports xhigh and max
• GPT Image 2.6 launch announcement
• Images API reference
• Choose an image generation API
• Call logs
• Model and pricing catalog

​

Sources

• OpenAI image generation guide
• OpenAI Images API reference