> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.beatapi.io/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.beatapi.io/_mcp/server.

# GPT Image 2.5 Flare

POST https://api.beatapi.io/v1/images/tasks
Content-Type: application/json

The fast default of the GPT Image 2.5 pair — natural lighting and rich textures, from text or up to sixteen public HTTPS reference images, across sixteen aspect ratios and output up to 4K.

### Supported modes

| Mode            | Required input              | Rules                                                   |
| --------------- | --------------------------- | ------------------------------------------------------- |
| Text to image   | `model`, `prompt`           | Omit `images`.                                          |
| Reference image | `model`, `prompt`, `images` | Provide 1–16 public HTTPS PNG, JPEG or WebP image URLs. |

**Async flow:** Create the task, save `data.id`, then [poll the Task](/quick-guide#get-task-status) with `GET /v1/tasks/{task_id}`. On `succeeded`, read `data.output.media`. On `failed`, read `data.error_code` and `data.error_message`, then follow the [error and retry policy](/quick-guide#errors-and-retry-policy).

**Using a local file?** [upload a local input](/quick-guide#upload-an-input-file) first and pass the returned `data.url`.

Reference: https://docs.beatapi.io/api-reference/image-api/gpt-image-2-5-flare

## Authentication

- `Authorization` header (bearer token, required) — Send your API key as `Authorization: Bearer <BEATAPI_API_KEY>`.

## Request

### Headers

- `Idempotency-Key` (string, optional)

### Body (application/json)

This endpoint expects a GptImage25FlareRequest.

- `model` ("gpt-image-2.5-flare", required) — Must be `gpt-image-2.5-flare`.
- `prompt` (string, required) — Generation or image-editing instructions.
- `images` (list of string, optional) — Public HTTPS reference-image URLs in PNG, JPEG or WebP; each link is checked when the task is created, and one that is not such an image (an error page, a GIF, a 404) is refused with 400. Omit for text-to-image.
- `aspect_ratio` (enum, optional, default: auto) — Output image aspect ratio. `auto` renders a square frame. Send `resolution` and `aspect_ratio`, or `size` instead of both — never together.
  - Allowed values: `auto`, `1:1`, `3:2`, `2:3`, `4:3`, `3:4`, `5:4`, `4:5`, `16:9`, `9:16`, `2:1`, `1:2`, `3:1`, `1:3`, `21:9`, `9:21`
- `resolution` (enum, optional, default: 1K) — Output resolution tier. Not with `size`.
  - Allowed values: `1K`, `2K`, `4K`
- `size` (string, optional) — Exact output size as WIDTHxHEIGHT, for example `1536x1024` or `3840x2160`. Replaces `resolution` and `aspect_ratio`; sending either with it is a 400. Both edges must be multiples of 16 and between 16 and 3840 px, the total between 655,360 and 8,294,400 pixels, and the long edge at most three times the short one. Billed as 1K up to 2,097,152 pixels, 2K up to 5,898,240 pixels, and 4K above.
- `background` (enum, optional, default: auto) — Output background. `transparent` returns a PNG with an alpha channel — describe the subject as isolated on a transparent background in the prompt. `opaque` always fills the backdrop; `auto` lets the model choose.
  - Allowed values: `auto`, `opaque`, `transparent`

## Response

### 201

Image generation task accepted

## Errors

### 400 Bad Request Error

Malformed JSON or a field, value or combination this endpoint does not accept (`bad_request`; the message names the field), or input refused by moderation (`content_policy_violation`). Not retryable unchanged.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 401 Unauthorized Error

No API key (`missing_api_key`), or a key that is wrong, expired, disabled or exhausted (`invalid_api_key`; the message says which). Send it as `Authorization: Bearer <key>`; the key works with or without the `sk-` prefix. Not retryable.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 402 Payment Required Error

Insufficient balance (`insufficient_credits`). The account balance is zero or below the price of this request. Top up, then send it again; not retryable before that.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 403 Forbidden Error

The key or account is not permitted to make this call (`forbidden`), for example a model that is not available on free credit (a top-up unlocks it), a request from outside the key's IP allowlist, or a model outside the key's group. Not retryable.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 409 Conflict Error

The `Idempotency-Key` was already used with a different request body, or the first request with it is still being processed (`idempotency_conflict`). Not retryable unchanged.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 429 Too Many Requests Error

Too many requests (`rate_limit_exceeded`, including the free-model limits) or too many tasks processing at once (`user_concurrency_exceeded`). Retryable after `Retry-After` seconds (also `error.retry_after_seconds`).

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 500 Internal Server Error

Unexpected internal error (`internal_error`). Retryable; keep `request_id` for support if it persists.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

### 503 Service Unavailable Error

The request could not be completed (`processing_unavailable`, `processing_timeout`, `processing_failed` or `result_transfer_failed`). Nothing was charged. Retryable with backoff; `Retry-After` is sent when the wait is known. BeatAPI does not answer 502 or 504.

- `error` (ErrorError, required) — Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

## Types

### ErrorError

Structured BeatAPI error. Use `code` (or `retryable`) for program logic and retain `request_id` for support.

- `code` (enum, required) — Stable machine-readable error code. `unauthorized` is the deprecated name for a 401; since 2026-09-29 a 401 is `missing_api_key` or `invalid_api_key`. Treat a legacy `unauthorized` like `invalid_api_key`.
  - Allowed values: `bad_request`, `missing_api_key`, `invalid_api_key`, `unauthorized`, `forbidden`, `not_found`, `insufficient_credits`, `idempotency_conflict`, `user_concurrency_exceeded`, `rate_limit_exceeded`, `content_policy_violation`, `processing_unavailable`, `processing_failed`, `processing_timeout`, `result_transfer_failed`, `invalid_signature`, `realtime_disabled`, `realtime_capacity_unavailable`, `realtime_session_expired`, `origin_not_allowed`, `invalid_client_secret`, `transport_not_allowed`, `internal_error`
- `message` (string, required) — English sentence that states the cause; for `bad_request` it names the field. Written for people and logs, not for parsing.
- `retryable` (boolean, required) — Whether making the same call again could succeed. Present on every error; branch on it instead of the status code. True for 429, 500 and 503 (rate_limit_exceeded, user_concurrency_exceeded, internal_error, processing_unavailable, processing_timeout, processing_failed, result_transfer_failed, realtime_capacity_unavailable). False for a request, key or balance that must change first (bad_request, content_policy_violation, missing_api_key, invalid_api_key, insufficient_credits, forbidden, not_found, idempotency_conflict, realtime_disabled and the other realtime credential codes).
- `request_id` (string, required) — Correlation ID to retain for BeatAPI support.
- `retry_after_seconds` (integer, optional) — Seconds to wait before retrying. Present on every 429, and on a 503 when the wait is known; the same value is sent in the `Retry-After` header.
- `docs` (string, optional) — The public Skill page that says what to do about an error. Present on errors answered by the capability endpoints (`/v1/capabilities/search`, `/v1/capabilities/inspect`, `/v1/capabilities/run`); absent on every other endpoint.

## Examples

### GPT Image 2.5 Flare

**Response**

```json
{
  "data": {
    "capability_id": "gpt-image-2.5-flare",
    "capability_version": null,
    "completed_at": null,
    "created_at": 1782210000,
    "error_code": null,
    "error_message": null,
    "id": "task_8K2qA",
    "media_type": "image",
    "model": "gpt-image-2.5-flare",
    "object": "task",
    "output": null,
    "request_id": "req_abc123",
    "stage": "queued",
    "status": "queued",
    "task_kind": "image",
    "updated_at": 1782210000,
    "usage": {
      "credits_charged": 0.04,
      "credits_refunded": 0,
      "credits_reserved": 0.04,
      "credits_settled": 0
    }
  }
}
```

**SDK Code**

```python GPT Image 2.5 Flare
import requests

url = "https://api.beatapi.io/v1/images/tasks"

headers = {"Authorization": "Bearer <token>"}

response = requests.post(url, headers=headers)

print(response.json())
```

```javascript GPT Image 2.5 Flare
const url = 'https://api.beatapi.io/v1/images/tasks';
const options = {method: 'POST', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go GPT Image 2.5 Flare
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.beatapi.io/v1/images/tasks"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby GPT Image 2.5 Flare
require 'uri'
require 'net/http'

url = URI("https://api.beatapi.io/v1/images/tasks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java GPT Image 2.5 Flare
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.beatapi.io/v1/images/tasks")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php GPT Image 2.5 Flare
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.beatapi.io/v1/images/tasks', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp GPT Image 2.5 Flare
using RestSharp;

var client = new RestClient("https://api.beatapi.io/v1/images/tasks");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift GPT Image 2.5 Flare
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.beatapi.io/v1/images/tasks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Text to image

**Request**

```json
{
  "model": "gpt-image-2.5-flare",
  "prompt": "A clean campaign image with soft studio lighting.",
  "aspect_ratio": "1:1",
  "resolution": "1K"
}
```

**Response**

```json
{
  "data": {
    "capability_id": "gpt-image-2.5-flare",
    "capability_version": null,
    "completed_at": null,
    "created_at": 1782210000,
    "error_code": null,
    "error_message": null,
    "id": "task_8K2qA",
    "media_type": "image",
    "model": "gpt-image-2.5-flare",
    "object": "task",
    "output": null,
    "request_id": "req_abc123",
    "stage": "queued",
    "status": "queued",
    "task_kind": "image",
    "updated_at": 1782210000,
    "usage": {
      "credits_charged": 0.04,
      "credits_refunded": 0,
      "credits_reserved": 0.04,
      "credits_settled": 0
    }
  }
}
```

**SDK Code**

```python Text to image
import requests

url = "https://api.beatapi.io/v1/images/tasks"

payload = {
    "model": "gpt-image-2.5-flare",
    "prompt": "A clean campaign image with soft studio lighting.",
    "aspect_ratio": "1:1",
    "resolution": "1K"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Text to image
const url = 'https://api.beatapi.io/v1/images/tasks';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"model":"gpt-image-2.5-flare","prompt":"A clean campaign image with soft studio lighting.","aspect_ratio":"1:1","resolution":"1K"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Text to image
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.beatapi.io/v1/images/tasks"

	payload := strings.NewReader("{\n  \"model\": \"gpt-image-2.5-flare\",\n  \"prompt\": \"A clean campaign image with soft studio lighting.\",\n  \"aspect_ratio\": \"1:1\",\n  \"resolution\": \"1K\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Text to image
require 'uri'
require 'net/http'

url = URI("https://api.beatapi.io/v1/images/tasks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"model\": \"gpt-image-2.5-flare\",\n  \"prompt\": \"A clean campaign image with soft studio lighting.\",\n  \"aspect_ratio\": \"1:1\",\n  \"resolution\": \"1K\"\n}"

response = http.request(request)
puts response.read_body
```

```java Text to image
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.beatapi.io/v1/images/tasks")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"model\": \"gpt-image-2.5-flare\",\n  \"prompt\": \"A clean campaign image with soft studio lighting.\",\n  \"aspect_ratio\": \"1:1\",\n  \"resolution\": \"1K\"\n}")
  .asString();
```

```php Text to image
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.beatapi.io/v1/images/tasks', [
  'body' => '{
  "model": "gpt-image-2.5-flare",
  "prompt": "A clean campaign image with soft studio lighting.",
  "aspect_ratio": "1:1",
  "resolution": "1K"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Text to image
using RestSharp;

var client = new RestClient("https://api.beatapi.io/v1/images/tasks");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"model\": \"gpt-image-2.5-flare\",\n  \"prompt\": \"A clean campaign image with soft studio lighting.\",\n  \"aspect_ratio\": \"1:1\",\n  \"resolution\": \"1K\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Text to image
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "model": "gpt-image-2.5-flare",
  "prompt": "A clean campaign image with soft studio lighting.",
  "aspect_ratio": "1:1",
  "resolution": "1K"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.beatapi.io/v1/images/tasks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Reference image

**Request**

```json
{
  "model": "gpt-image-2.5-flare",
  "prompt": "Create a clean campaign image from the supplied product reference.",
  "images": [
    "https://media.beatapi.io/samples/smart-bottle.png"
  ],
  "aspect_ratio": "16:9",
  "resolution": "2K"
}
```

**Response**

```json
{
  "data": {
    "capability_id": "gpt-image-2.5-flare",
    "capability_version": null,
    "completed_at": null,
    "created_at": 1782210000,
    "error_code": null,
    "error_message": null,
    "id": "task_8K2qA",
    "media_type": "image",
    "model": "gpt-image-2.5-flare",
    "object": "task",
    "output": null,
    "request_id": "req_abc123",
    "stage": "queued",
    "status": "queued",
    "task_kind": "image",
    "updated_at": 1782210000,
    "usage": {
      "credits_charged": 0.04,
      "credits_refunded": 0,
      "credits_reserved": 0.04,
      "credits_settled": 0
    }
  }
}
```

**SDK Code**

```python Reference image
import requests

url = "https://api.beatapi.io/v1/images/tasks"

payload = {
    "model": "gpt-image-2.5-flare",
    "prompt": "Create a clean campaign image from the supplied product reference.",
    "images": ["https://media.beatapi.io/samples/smart-bottle.png"],
    "aspect_ratio": "16:9",
    "resolution": "2K"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Reference image
const url = 'https://api.beatapi.io/v1/images/tasks';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"model":"gpt-image-2.5-flare","prompt":"Create a clean campaign image from the supplied product reference.","images":["https://media.beatapi.io/samples/smart-bottle.png"],"aspect_ratio":"16:9","resolution":"2K"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Reference image
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.beatapi.io/v1/images/tasks"

	payload := strings.NewReader("{\n  \"model\": \"gpt-image-2.5-flare\",\n  \"prompt\": \"Create a clean campaign image from the supplied product reference.\",\n  \"images\": [\n    \"https://media.beatapi.io/samples/smart-bottle.png\"\n  ],\n  \"aspect_ratio\": \"16:9\",\n  \"resolution\": \"2K\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Reference image
require 'uri'
require 'net/http'

url = URI("https://api.beatapi.io/v1/images/tasks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"model\": \"gpt-image-2.5-flare\",\n  \"prompt\": \"Create a clean campaign image from the supplied product reference.\",\n  \"images\": [\n    \"https://media.beatapi.io/samples/smart-bottle.png\"\n  ],\n  \"aspect_ratio\": \"16:9\",\n  \"resolution\": \"2K\"\n}"

response = http.request(request)
puts response.read_body
```

```java Reference image
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.beatapi.io/v1/images/tasks")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"model\": \"gpt-image-2.5-flare\",\n  \"prompt\": \"Create a clean campaign image from the supplied product reference.\",\n  \"images\": [\n    \"https://media.beatapi.io/samples/smart-bottle.png\"\n  ],\n  \"aspect_ratio\": \"16:9\",\n  \"resolution\": \"2K\"\n}")
  .asString();
```

```php Reference image
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.beatapi.io/v1/images/tasks', [
  'body' => '{
  "model": "gpt-image-2.5-flare",
  "prompt": "Create a clean campaign image from the supplied product reference.",
  "images": [
    "https://media.beatapi.io/samples/smart-bottle.png"
  ],
  "aspect_ratio": "16:9",
  "resolution": "2K"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Reference image
using RestSharp;

var client = new RestClient("https://api.beatapi.io/v1/images/tasks");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"model\": \"gpt-image-2.5-flare\",\n  \"prompt\": \"Create a clean campaign image from the supplied product reference.\",\n  \"images\": [\n    \"https://media.beatapi.io/samples/smart-bottle.png\"\n  ],\n  \"aspect_ratio\": \"16:9\",\n  \"resolution\": \"2K\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Reference image
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "model": "gpt-image-2.5-flare",
  "prompt": "Create a clean campaign image from the supplied product reference.",
  "images": ["https://media.beatapi.io/samples/smart-bottle.png"],
  "aspect_ratio": "16:9",
  "resolution": "2K"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.beatapi.io/v1/images/tasks")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```