GPT Image 2.6

GPT Image 2.6 (product gpt_image) generates images from a prompt, optionally guided by up to 16 reference images. Like GPT Image 2.5 it has two variants (flare and sunburst), five quality levels and transparent backgrounds, at the same price; it adds the output format (png, jpeg, webp, an animated gif or a vector svg) and an exact width and height (size). One task makes 1–4 images, billed per image by quality and resolution.

Create a task

Use the shared create endpoint with model: "gpt-image-2.6". It usually responds in under 1 second, and the cost of num_outputs images is frozen within a few seconds. Get the result once the task has finished.

Headers

Body

Any other parameter, such as the other image models' seed or remove_bg, returns 400 invalid_request, see Errors.

Output formats

frame_count and frame_duration_ms are only accepted with gif: remove them when you switch to another format.

Size rules

A size that breaks these rules returns 400 invalid_request with param "size":

The total pixels can't go over the resolution's cap (only the total counts, not the long side):

For a larger image, raise resolution (svg only takes 1k, so at most 1075200 pixels). A size smaller than the tier works but is billed at the tier you sent: 4k with 1024x768 gives a 1024×768 image at the 4k price, so pick the lowest resolution that fits. Sizes that work for gif: 288x288, 512x512, 768x768, 512x288, 288x512, 912x304.

Two 16:9 WebP images from one reference image, at an exact 2048×1152 and high quality:

curl https://api.nanoapi.ai/v1/tasks \
  -H "Authorization: Bearer $NANOAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: 7c3f1e92-4a6b-4d0e-9b8f-5e2a1c7d9f34" \
  -d '{
    "model": "gpt-image-2.6",
    "prompt": "Put a red apple next to the mug in @Image1",
    "image_urls": ["https://example.com/mug.jpg"],
    "variant": "flare",
    "quality": "high",
    "resolution": "2k",
    "output_format": "webp",
    "size": "2048x1152",
    "num_outputs": 2
  }'

An animated GIF: 4 frames of 512×512, 100 ms each (gif needs 1k, size, frame_count and frame_duration_ms, and no aspect_ratio):

curl https://api.nanoapi.ai/v1/tasks \
  -H "Authorization: Bearer $NANOAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: 1b8d4f60-2e7a-4c93-a5d1-8f0e6b3c2a17" \
  -d '{
    "model": "gpt-image-2.6",
    "prompt": "A red ball bouncing up and down, simple looping animation",
    "variant": "flare",
    "quality": "low",
    "resolution": "1k",
    "output_format": "gif",
    "size": "512x512",
    "frame_count": 4,
    "frame_duration_ms": 100,
    "num_outputs": 1
  }'

A square SVG logo (svg needs 1k and takes no image_urls):

curl https://api.nanoapi.ai/v1/tasks \
  -H "Authorization: Bearer $NANOAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: 9e2a7c15-6d3b-4f8e-b0a4-3c1f5d7e9b62" \
  -d '{
    "model": "gpt-image-2.6",
    "prompt": "A flat minimalist fox logo",
    "variant": "flare",
    "quality": "medium",
    "resolution": "1k",
    "output_format": "svg",
    "aspect_ratio": "1:1",
    "num_outputs": 1
  }'

Response: 200 OK. data is the newly created task, with only these fields; each one is described in Create a task: Response. Keep data.id to get the result. The task can still fail after it's created (for example if your balance can't cover it), so go by what retrieving the task or the webhook tells you.

{
  "code": 200,
  "message": "success",
  "data": {
    "object": "task",
    "id": "tk_01jbm2r7c5x8v1n4q6t9w3e0y2",
    "model": "gpt-image-2.6",
    "status": "queued",
    "error": null,
    "created_at": "2026-11-05T08:30:00Z"
  }
}

Get the result

As a rough guide (generation only, not counting the queue, plus a few seconds to store the files; slower when the provider is busy): png at 1k about 20 seconds, gif and svg about 25–45 seconds; higher quality, sunburst and reference images take longer. The images of a task are generated in parallel, so several take about as long as one. Once the task has finished (succeeded or failed), get the result either way:

• Webhook (recommended in production): if you passed webhook_url, the full task is pushed to it once when the task finishes. See Webhooks.
• Polling: call GET /v1/tasks/{task_id} with data.id at most once every 15 seconds until status is succeeded or failed. Check several tasks at once with ids in List tasks.

The WebP request above, once it has succeeded (other fields left out):

{
  "status": "succeeded",
  "input": {
    "prompt": "Put a red apple next to the mug in @Image1",
    "image_urls": ["https://example.com/mug.jpg"],
    "variant": "flare",
    "quality": "high",
    "resolution": "2k",
    "output_format": "webp",
    "size": "2048x1152"
  },
  "num_outputs": 2,
  "outputs": [
    {
      "index": 0,
      "type": "image",
      "url": "https://cdn.nanoapi.ai/h/tk_01jbm2r7c5x8v1n4q6t9w3e0y2_1_1793867400.webp",
      "preview_url": "https://cdn.nanoapi.ai/h/tk_01jbm2r7c5x8v1n4q6t9w3e0y2_1_1793867400_compressed.jpg"
    },
    {
      "index": 1,
      "type": "image",
      "url": "https://cdn.nanoapi.ai/h/tk_01jbm2r7c5x8v1n4q6t9w3e0y2_2_1793867400.webp",
      "preview_url": "https://cdn.nanoapi.ai/h/tk_01jbm2r7c5x8v1n4q6t9w3e0y2_2_1793867400_compressed.jpg"
    }
  ],
  "billing": {
    "currency": "USD",
    "frozen": "…", // 2 × the high 2k price per image
    "charged": "…", // the same: both images were generated
    "refunded": "0.00",
    "billed_seconds": null
  }
}

On failure the frozen amount is returned in full and the reason is in data.error.type, see Errors. Every field is described in The task object.

Image sizes

With aspect_ratio, the sizes are the same as GPT Image 2.5's, see GPT Image 2.5 → Image sizes; quality, variant and output_format don't change them, and the size of auto depends on the reference images. With size, the image is exactly that size (for gif, each frame).

Fewer images than requested

Each image is generated on its own. If some can't be made (for example because moderation blocked them), the task still succeeded: outputs only has the images that were generated, fewer than num_outputs. Only those are charged and the rest of the frozen amount is returned (billing.refunded). The task fails only when no image could be generated, and then everything frozen is returned: if at least one of them was blocked by moderation, the reason is content_policy (not every image has to be blocked), otherwise usually generation_failed. outputs[].index numbers the generated images from 0 without gaps, so when there are fewer it doesn't match the position in your request: don't use it to pair images with anything.

Media

Reference images are passed in image_urls as public http(s) URLs. There's no upload endpoint: host the files yourself. URLs are at most 4096 characters, must download directly and can't point to localhost or private, loopback or reserved addresses.

Keep every link reachable until the task finishes, including links that expire.

Referring to images in the prompt

• A reference beyond the images you sent (for example @Image2 with one image, or any @Image without image_urls) returns 400 invalid_request with param "prompt", and no task is created.
• An @ right after a letter, digit or dot isn't a reference, so an email address such as bob@image2go.com in the prompt is fine.

Pricing

frozen  = price per image of the quality and resolution × num_outputs
charged = price per image of the quality and resolution × images generated

Loading the current prices…

• The same prices as GPT Image 2.5: both models are in product gpt_image and share its price rows.
• Only quality and resolution change the price. variant, output_format, size, aspect_ratio, the frame count and duration, background and reference images don't.
• size doesn't lower the price: a size smaller than the resolution tier is billed at the tier, see Size rules.
• The cost of all num_outputs images is frozen within a few seconds of creating the task. When it succeeds, each generated image is charged and the rest is returned, see Fewer images than requested; when it fails, all of it is returned.

Example: the WebP request above (high, 2k, num_outputs 2) freezes 2 × the high 2k price per image and is charged the same when both images are generated; the GIF request freezes 1 × the low 1k price, whatever the number of frames. How freezing and charging work in general: Billing.

The price is known from the request, so you can show it before submitting: read the current prices from GET /v1/products (product gpt_image, one prices row per quality and resolution). Prices change, so don't hard-code them; billing.frozen on the retrieved task is what counts.

Errors

Errors and failure reasons specific to this model. Every error of the create endpoint: Create a task → Errors; every failure reason: Failure reasons.

Create request errors: the request fails with an HTTP error and no task is created. param names the parameter; message explains it in English and can be shown to your users as is.

Other errors of the create endpoint (401, 402, 429 and so on): Create a task → Errors.

Task failures: the create request succeeded (200) and the task later turned failed. There's no HTTP status: the reason is the task's error.type, from retrieving the task or the webhook.

Every failed task has its frozen amount returned in full and billing.charged "0.00".