gpt-image-2.6-flare-official

Quick example

curl https://reapi.ai/api/v1/images/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-flare-official",
    "prompt": "A red paper crane flapping its wings in a seamless loop",
    "output_format": "gif",
    "size": "512x512",
    "quality": "low",
    "frame_count": 4
  }'

import requests

resp = requests.post(
    "https://reapi.ai/api/v1/images/generations",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "model": "gpt-image-2.6-flare-official",
        "prompt": "A red paper crane flapping its wings in a seamless loop",
        "output_format": "gif",
        "size": "512x512",
        "quality": "low",
        "frame_count": 4,
    },
)
task_id = resp.json()["id"]

const res = await fetch('https://reapi.ai/api/v1/images/generations', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'gpt-image-2.6-flare-official',
    prompt: 'A red paper crane flapping its wings in a seamless loop',
    output_format: 'gif',
    size: '512x512',
    quality: 'low',
    frame_count: 4,
  }),
});
const { id } = await res.json();

body := strings.NewReader(`{
  "model": "gpt-image-2.6-flare-official",
  "prompt": "A red paper crane flapping its wings in a seamless loop",
  "output_format": "gif",
  "size": "512x512",
  "quality": "low",
  "frame_count": 4
}`)

req, _ := http.NewRequest("POST", "https://reapi.ai/api/v1/images/generations", body)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
resp, err := http.DefaultClient.Do(req)

Authentication

Every call needs a Bearer token. Generate keys at reapi.ai/settings/apikeys.

Authorization: Bearer YOUR_API_KEY

Endpoint

POST /api/v1/images/generations
GET  /api/v1/tasks/{id}

Submission is async. The POST returns a task id immediately; poll the task endpoint until status is completed or failed. Polling does not consume credits.

Variants

Two variants, one parameter shape. Pick via model:

Both meter on the same token rate card. Equal rates do not mean equal cost per image: the token count depends on the request — see Pricing.

Request body

There is no mode parameter: the fields you send decide the job.

Checked before anything is submitted or charged:

• mask_url and markup_url each need at least one image_urls entry, and cannot be combined
• gif and svg output are for new generations: no image_urls, mask_url or markup_url
• svg returns one file: n must be 1
• frame_count and frame_duration_ms need output_format: "gif"
• background: "transparent" cannot be combined with jpeg
• image URLs must be public HTTP(S) and carry no credentials (user:pass@)
• size follows the rules below

Size rules

For png, jpeg and svg, a custom WIDTHxHEIGHT is accepted when:

• both edges are divisible by 16
• the aspect ratio is between 1:3 and 3:1
• neither edge exceeds 3840 pixels
• the total pixel count is between 655,360 and 8,294,400

For gif, both edges must be divisible by 16 and the minimum pixel count does not apply, so 512x512 is valid. The frames are laid out on one sheet (see GIF output), and that sheet must also fit within 3840 pixels per edge: two 1024x1024 frames are refused because their sheet would be 4096x2048. The refusal comes after submission and is refunded in full.

GIF output

Set output_format: "gif" and the task returns one animated GIF. The frames are rendered as a single sheet: up to 8 frames on a 4 × 2 grid, 9 frames on 3 × 3, and 16 frames on 4 × 4. size: "auto" renders 512x512 frames.

{
  "model": "gpt-image-2.6-flare-official",
  "prompt": "A round orange fox mascot waving one paw in a seamless loop",
  "output_format": "gif",
  "size": "512x512",
  "frame_count": 9,
  "frame_duration_ms": 200
}

OpenAI's image generation guide gives 2–64 frames and 20–2,000 ms, while its Images API reference gives 2–16 frames and no duration maximum. The upstream follows the reference: 17 frames are rejected and a 3,000 ms frame is accepted. It also follows the guide in one respect: GIF is generation-only, and a GIF requested with reference images is rejected.

SVG output

Set output_format: "svg" and the task returns a static SVG file with editable paths, shapes and colors — for icons, logos and flat illustrations. SVG takes no reference images, mask or markup, and returns one file per request. A second model writes the SVG; its tokens are billed on top of the image tokens (see Pricing).

Markup-guided edits

Draw your marks on a transparent PNG the same size as the first reference image, pass it as markup_url, and describe the change in the prompt.

{
  "model": "gpt-image-2.6-sunburst-official",
  "prompt": "Recolor the circled vase blue, keep everything else",
  "image_urls": ["https://example.com/kitchen.png"],
  "markup_url": "https://example.com/vase-circle.png",
  "complexity": "low"
}

Markup applies to the first reference image; further images act as references. It cannot be combined with a mask.

Troubleshooting

Response envelope

{
  "id": "task_...",
  "model": "gpt-image-2.6-flare-official",
  "status": "completed",
  "output": {
    "image_urls": ["https://cdn.reapi.ai/media/tasks/.../0.gif"]
  },
  "usage": {
    "credits": 0
  }
}

output.image_urls holds one URL per result; the extension follows the format (.png, .jpg, .gif or .svg). Download a GIF from its URL to keep every frame. Generated links expire, so mirror them if you need them long term.

Pricing

GPT Image 2.6 bills per token, at OpenAI's published rates for the model:

credits = ceil(metered_usd × 1000)     1 credit = $0.001

metered_usd covers the text input, image input and image output tokens the upstream reports for the task, plus the SVG author's tokens on svg output. Live rates are on the model page. The amount reserved at submit is an estimate; the final charge uses the reported tokens, and failed jobs are refunded in full.

The parts worth reading are what moves the token count.

1. Quality is the dominant term

Measured for one 1024x1024 image on gpt-image-2.6-flare-official:

The frame changes the count too, and not always upward: at low, 1536x1024 measured 664 output tokens against 824 for 1024x1024. complexity does not change it: low, medium and high all measured 824 at 1024x1024 low. n multiplies the whole request.

2. A GIF is billed as one frame sheet, not per frame

The frames are rendered on one sheet and billed as one image the size of that sheet. With 512x512 frames at low:

3. SVG adds the author model's tokens

An SVG is billed for its image tokens plus the input and output tokens of the model that writes the vector file, at that model's own rates. One measured SVG used about 2,200 input and 2,100 output tokens for the vector step.

4. Reference images add input tokens

Each reference image adds image input tokens: one 1024x1024 reference measured 1,024.

Related

• Errors catalog
• Authentication
• Quickstart
• GPT Image 2.5 — the previous generation