curl --request POST \
  --url https://aireiter.com/api/openapi/submit \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "gpt_image_2_official",
    "params": {
      "prompt": "Ancient castle under the starry sky",
      "aspect_ratio": "16:9",
      "resolution": "2K",
      "quality": "high"
    },
    "out_task_id": "my_task_123456"
  }'

import requests

url = "https://aireiter.com/api/openapi/submit"

payload = {
    "model": "gpt_image_2_official",
    "params": {
        "prompt": "Ancient castle under the starry sky",
        "aspect_ratio": "16:9",
        "resolution": "2K",
        "quality": "high"
    },
    "out_task_id": "my_task_123456"
}

headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())

const url = "https://aireiter.com/api/openapi/submit";

const payload = {
  model: "gpt_image_2_official",
  params: {
    prompt: "Ancient castle under the starry sky",
    aspect_ratio: "16:9",
    resolution: "2K",
    quality: "high",
  },
  out_task_id: "my_task_123456",
};

const headers = {
  Authorization: "Bearer <token>",
  "Content-Type": "application/json",
};

fetch(url, {
  method: "POST",
  headers: headers,
  body: JSON.stringify(payload),
})
  .then((response) => response.json())
  .then((data) => console.log(data))
  .catch((error) => console.error("Error:", error));

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://aireiter.com/api/openapi/submit"

    payload := map[string]interface{}{
        "model": "gpt_image_2_official",
        "params": map[string]interface{}{
            "prompt":     "Ancient castle under the starry sky",
            "aspect_ratio":       "16:9",
            "resolution": "2K",
            "quality":    "high",
        },
        "out_task_id": "my_task_123456",
    }

    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer <token>")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String url = "https://aireiter.com/api/openapi/submit";

        String payload = """
        {
          "model": "gpt_image_2_official",
          "params": {
            "prompt": "Ancient castle under the starry sky",
            "aspect_ratio": "16:9",
            "resolution": "2K",
            "quality": "high"
          },
          "out_task_id": "my_task_123456"
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer <token>")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

<?php

$url = "https://aireiter.com/api/openapi/submit";

$payload = [
    "model" => "gpt_image_2_official",
    "params" => [
        "prompt" => "Ancient castle under the starry sky",
        "aspect_ratio" => "16:9",
        "resolution" => "2K",
        "quality" => "high"
    ],
    "out_task_id" => "my_task_123456"
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

require 'net/http'
require 'json'
require 'uri'

url = URI("https://aireiter.com/api/openapi/submit")

payload = {
  model: "gpt_image_2_official",
  params: {
    prompt: "Ancient castle under the starry sky",
    aspect_ratio: "16:9",
    resolution: "2K",
    quality: "high"
  },
  out_task_id: "my_task_123456"
}

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 = payload.to_json

response = http.request(request)
puts response.body

import Foundation

let url = URL(string: "https://aireiter.com/api/openapi/submit")!

let payload: [String: Any] = [
    "model": "gpt_image_2_official",
    "params": [
        "prompt": "Ancient castle under the starry sky",
        "aspect_ratio": "16:9",
        "resolution": "2K",
        "quality": "high"
    ],
    "out_task_id": "my_task_123456"
]

var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    if let data = data, let responseString = String(data: data, encoding: .utf8) {
        print(responseString)
    }
}

task.resume()

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var url = "https://aireiter.com/api/openapi/submit";

        var payload = @"{
            ""model"": ""gpt_image_2_official"",
            ""params"": {
                ""prompt"": ""Ancient castle under the starry sky"",
                ""aspect_ratio"": ""16:9"",
                ""resolution"": ""2K"",
                ""quality"": ""high""
            },
            ""out_task_id"": ""my_task_123456""
        }";

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");

        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await client.PostAsync(url, content);
        var result = await response.Content.ReadAsStringAsync();

        Console.WriteLine(result);
    }
}

import 'dart:convert';
import 'package:http/http.dart' as http;

void main() async {
  final url = Uri.parse('https://aireiter.com/api/openapi/submit');

  final payload = {
    'model': 'gpt_image_2_official',
    'params': {
      'prompt': 'Ancient castle under the starry sky',
      'aspect_ratio': '16:9',
      'resolution': '2K',
      'quality': 'high',
    },
    'out_task_id': 'my_task_123456',
  };

  final response = await http.post(
    url,
    headers: {
      'Authorization': 'Bearer <token>',
      'Content-Type': 'application/json',
    },
    body: jsonEncode(payload),
  );

  print(response.body);
}

library(httr)
library(jsonlite)

url <- "https://aireiter.com/api/openapi/submit"

payload <- list(
  model = "gpt_image_2_official",
  params = list(
    prompt = "Ancient castle under the starry sky",
    aspect_ratio = "16:9",
    resolution = "2K",
    quality = "high"
  ),
  out_task_id = "my_task_123456"
)

response <- POST(
  url,
  add_headers(
    Authorization = "Bearer <token>",
    `Content-Type` = "application/json"
  ),
  body = toJSON(payload, auto_unbox = TRUE),
  encode = "raw"
)

cat(content(response, "text"))

{
  "code": 200,
  "data": [
    {
      "status": "submitted",
      "task_id": "task_01KPTXXXXXXXXXXXXXXX"
    }
  ]
}

{
  "error": {
    "code": 400,
    "message": "resolution 4K not supported for size 1:1, allowed: 1K / 2K",
    "type": "invalid_request_error"
  }
}

{
  "error": {
    "code": 401,
    "message": "Authentication failed, please check your API key",
    "type": "authentication_error"
  }
}

{
  "error": {
    "code": 402,
    "message": "Insufficient account balance, please recharge and try again",
    "type": "payment_required"
  }
}

{
  "error": {
    "code": 429,
    "message": "Too many requests, please try again later",
    "type": "rate_limit_error"
  }
}

{
  "error": {
    "code": 500,
    "message": "Internal server error, please try again later",
    "type": "server_error"
  }
}

GPT-Image-2

GPT-Image-2 Official Channel Image Generation

Official OpenAI gpt-image-2 model, compatible with the /v1/images/generations protocol
Asynchronous processing mode, returns task_id for subsequent queries
Text-to-image / Image-to-image all-in-one
Added resolution tier field, supports 1K / 2K / 4K resolution options
Supports 13 aspect ratios (4K tier supports 6 of them: 16:9 / 9:16 / 2:1 / 1:2 / 21:9 / 9:21)
Up to 9 reference images, supports mixed URL and base64
Submitted prompts undergo platform sensitive words / safety review, violating content will be directly rejected

POST

api

openapi

submit

curl --request POST \
  --url https://aireiter.com/api/openapi/submit \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "gpt_image_2_official",
    "params": {
      "prompt": "Ancient castle under the starry sky",
      "aspect_ratio": "16:9",
      "resolution": "2K",
      "quality": "high"
    },
    "out_task_id": "my_task_123456"
  }'

import requests

url = "https://aireiter.com/api/openapi/submit"

payload = {
    "model": "gpt_image_2_official",
    "params": {
        "prompt": "Ancient castle under the starry sky",
        "aspect_ratio": "16:9",
        "resolution": "2K",
        "quality": "high"
    },
    "out_task_id": "my_task_123456"
}

headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())

const url = "https://aireiter.com/api/openapi/submit";

const payload = {
  model: "gpt_image_2_official",
  params: {
    prompt: "Ancient castle under the starry sky",
    aspect_ratio: "16:9",
    resolution: "2K",
    quality: "high",
  },
  out_task_id: "my_task_123456",
};

const headers = {
  Authorization: "Bearer <token>",
  "Content-Type": "application/json",
};

fetch(url, {
  method: "POST",
  headers: headers,
  body: JSON.stringify(payload),
})
  .then((response) => response.json())
  .then((data) => console.log(data))
  .catch((error) => console.error("Error:", error));

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://aireiter.com/api/openapi/submit"

    payload := map[string]interface{}{
        "model": "gpt_image_2_official",
        "params": map[string]interface{}{
            "prompt":     "Ancient castle under the starry sky",
            "aspect_ratio":       "16:9",
            "resolution": "2K",
            "quality":    "high",
        },
        "out_task_id": "my_task_123456",
    }

    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer <token>")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String url = "https://aireiter.com/api/openapi/submit";

        String payload = """
        {
          "model": "gpt_image_2_official",
          "params": {
            "prompt": "Ancient castle under the starry sky",
            "aspect_ratio": "16:9",
            "resolution": "2K",
            "quality": "high"
          },
          "out_task_id": "my_task_123456"
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer <token>")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

<?php

$url = "https://aireiter.com/api/openapi/submit";

$payload = [
    "model" => "gpt_image_2_official",
    "params" => [
        "prompt" => "Ancient castle under the starry sky",
        "aspect_ratio" => "16:9",
        "resolution" => "2K",
        "quality" => "high"
    ],
    "out_task_id" => "my_task_123456"
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

require 'net/http'
require 'json'
require 'uri'

url = URI("https://aireiter.com/api/openapi/submit")

payload = {
  model: "gpt_image_2_official",
  params: {
    prompt: "Ancient castle under the starry sky",
    aspect_ratio: "16:9",
    resolution: "2K",
    quality: "high"
  },
  out_task_id: "my_task_123456"
}

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 = payload.to_json

response = http.request(request)
puts response.body

import Foundation

let url = URL(string: "https://aireiter.com/api/openapi/submit")!

let payload: [String: Any] = [
    "model": "gpt_image_2_official",
    "params": [
        "prompt": "Ancient castle under the starry sky",
        "aspect_ratio": "16:9",
        "resolution": "2K",
        "quality": "high"
    ],
    "out_task_id": "my_task_123456"
]

var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    if let data = data, let responseString = String(data: data, encoding: .utf8) {
        print(responseString)
    }
}

task.resume()

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var url = "https://aireiter.com/api/openapi/submit";

        var payload = @"{
            ""model"": ""gpt_image_2_official"",
            ""params"": {
                ""prompt"": ""Ancient castle under the starry sky"",
                ""aspect_ratio"": ""16:9"",
                ""resolution"": ""2K"",
                ""quality"": ""high""
            },
            ""out_task_id"": ""my_task_123456""
        }";

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");

        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await client.PostAsync(url, content);
        var result = await response.Content.ReadAsStringAsync();

        Console.WriteLine(result);
    }
}

import 'dart:convert';
import 'package:http/http.dart' as http;

void main() async {
  final url = Uri.parse('https://aireiter.com/api/openapi/submit');

  final payload = {
    'model': 'gpt_image_2_official',
    'params': {
      'prompt': 'Ancient castle under the starry sky',
      'aspect_ratio': '16:9',
      'resolution': '2K',
      'quality': 'high',
    },
    'out_task_id': 'my_task_123456',
  };

  final response = await http.post(
    url,
    headers: {
      'Authorization': 'Bearer <token>',
      'Content-Type': 'application/json',
    },
    body: jsonEncode(payload),
  );

  print(response.body);
}

library(httr)
library(jsonlite)

url <- "https://aireiter.com/api/openapi/submit"

payload <- list(
  model = "gpt_image_2_official",
  params = list(
    prompt = "Ancient castle under the starry sky",
    aspect_ratio = "16:9",
    resolution = "2K",
    quality = "high"
  ),
  out_task_id = "my_task_123456"
)

response <- POST(
  url,
  add_headers(
    Authorization = "Bearer <token>",
    `Content-Type` = "application/json"
  ),
  body = toJSON(payload, auto_unbox = TRUE),
  encode = "raw"
)

cat(content(response, "text"))

{
  "code": 200,
  "data": [
    {
      "status": "submitted",
      "task_id": "task_01KPTXXXXXXXXXXXXXXX"
    }
  ]
}

{
  "error": {
    "code": 400,
    "message": "resolution 4K not supported for size 1:1, allowed: 1K / 2K",
    "type": "invalid_request_error"
  }
}

{
  "error": {
    "code": 401,
    "message": "Authentication failed, please check your API key",
    "type": "authentication_error"
  }
}

{
  "error": {
    "code": 402,
    "message": "Insufficient account balance, please recharge and try again",
    "type": "payment_required"
  }
}

{
  "error": {
    "code": 429,
    "message": "Too many requests, please try again later",
    "type": "rate_limit_error"
  }
}

{
  "error": {
    "code": 500,
    "message": "Internal server error, please try again later",
    "type": "server_error"
  }
}

Authorizations

string

required

All endpoints require authentication using a Bearer Token.Get your API Key:Visit the API Key Management Page to obtain your API Key.Add the following to the request header when using:

Authorization: Bearer YOUR_API_KEY

Body

string

default:"gpt_image_2_official"

required

Name of the image generation modelFixed value gpt_image_2_official (OpenAI official gpt-image-2 model)

object

required

Model parameters object

Show params object properties

string

required

Text description for image generation

Supports Chinese and English, detailed description recommended
Will be checked by platform sensitive word / security review before submitting; violation will cause an error response

string

default:"1:1"

Aspect ratioExternally used ratio values; internally mapped to specific pixels according to resolution.Supports 13 ratios:

1:1 - Square composition (default, social avatar / logo)
3:2 - Landscape composition (common DSLR ratio)
2:3 - Portrait composition (poster vertical)
4:3 - Landscape composition (classic monitor / PPT)
3:4 - Portrait composition
5:4 - Landscape composition
4:5 - Portrait composition (Instagram vertical post)
16:9 - Landscape composition (widescreen video cover)
9:16 - Portrait composition (full-screen phone / short video cover)
2:1 - Landscape composition (web banner)
1:2 - Portrait composition
21:9 - Landscape composition (cinema widescreen)
9:21 - Portrait composition

Only ratio format is supported; pixel size inputs (e.g. 1024x1024) will cause an error

string

default:"1K"

Resolution tierControls actual image clarity:

1K - 1024 baseline, cost-effective for daily use (default)
2K - 2048 baseline, suitable for posters / HD needs
4K - 3840 baseline, supported only by 6 ratios (16:9 / 9:16 / 2:1 / 1:2 / 21:9 / 9:21)

Unsupported 4K combinations will return 400 error:

1:1 × 4K ❌ (exceeds pixel limit)
3:2 / 2:3 × 4K ❌ (exceeds pixel limit)
4:3 / 3:4 × 4K ❌ (exceeds pixel limit)
5:4 / 4:5 × 4K ❌ (exceeds pixel limit)

For HD images in these ratios, use resolution=2K instead.

string

default:"low"

Image quality

low - Fast and cost-saving, contour adequate (default)
medium - Balanced
high - Highest precision (4K + high consumes >120 seconds)

array

Reference image array, uses image-to-image mode when provided

Up to 9 reference images
Supports two formats:
1. Publicly accessible URL
2. Base64 encoded format
  - Must use full Data URI format: data:image/{format};base64,{base64 data}
  - Supported image formats: jpeg, png, webp
  - Example: data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABg...
  - ⚠️ Note: must include the data:image/jpeg;base64, prefix

string

required

Initiator task IDUser-defined task identifier, required

Size × Resolution Mapping Table

aspect_ratio × resolution → OpenAI Actual Pixels (13 ratios × 3 tiers):

aspect_ratio	`1K`	`2K`	`4K`
`1:1`	1024×1024	2048×2048	❌ Pixel limit exceeded
`3:2`	1536×1024	2048×1360	❌ Pixel limit exceeded
`2:3`	1024×1536	1360×2048	❌ Pixel limit exceeded
`4:3`	1024×768	2048×1536	❌ Pixel limit exceeded
`3:4`	768×1024	1536×2048	❌ Pixel limit exceeded
`5:4`	1280×1024	2560×2048	❌ Pixel limit exceeded
`4:5`	1024×1280	2048×2560	❌ Pixel limit exceeded
`16:9`	1536×864	2048×1152	3840×2160
`9:16`	864×1536	1152×2048	2160×3840
`2:1`	2048×1024	2688×1344	3840×1920
`1:2`	1024×2048	1344×2688	1920×3840
`21:9`	2016×864	2688×1152	3840×1648
`9:21`	864×2016	1152×2688	1648×3840

3:2 / 2:3 @ 2K are actually 2048×1360 (approximate ratio, error < 0.5%); 4K supports only 6 ratios (combinations exceeding OpenAI’s total pixel limit are unavailable).

Response

integer

Response status code

array

Returned data array

Show Properties

string

Task status

submitted - Submitted

string

Unique task identifier, used for subsequent querying of the task result

Query Task Result

Upon successful submission, a task_id is returned. Poll the task status using GET /v1/tasks/{task_id}. For details, see the Task Query Endpoint.

Polling Recommendations

Initial Query Delay: Wait 10~20 seconds after submission before starting to query
Query Interval: Recommend every 3~5 seconds
Timeout Reference: high + 2K/4K combination can take up to 130 seconds; client timeout recommendation ≥ 180 seconds

curl --request POST \
  --url https://aireiter.com/api/openapi/submit \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "gpt_image_2_official",
    "params": {
      "prompt": "Ancient castle under the starry sky",
      "aspect_ratio": "16:9",
      "resolution": "2K",
      "quality": "high"
    },
    "out_task_id": "my_task_123456"
  }'

import requests

url = "https://aireiter.com/api/openapi/submit"

payload = {
    "model": "gpt_image_2_official",
    "params": {
        "prompt": "Ancient castle under the starry sky",
        "aspect_ratio": "16:9",
        "resolution": "2K",
        "quality": "high"
    },
    "out_task_id": "my_task_123456"
}

headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())

const url = "https://aireiter.com/api/openapi/submit";

const payload = {
  model: "gpt_image_2_official",
  params: {
    prompt: "Ancient castle under the starry sky",
    aspect_ratio: "16:9",
    resolution: "2K",
    quality: "high",
  },
  out_task_id: "my_task_123456",
};

const headers = {
  Authorization: "Bearer <token>",
  "Content-Type": "application/json",
};

fetch(url, {
  method: "POST",
  headers: headers,
  body: JSON.stringify(payload),
})
  .then((response) => response.json())
  .then((data) => console.log(data))
  .catch((error) => console.error("Error:", error));

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://aireiter.com/api/openapi/submit"

    payload := map[string]interface{}{
        "model": "gpt_image_2_official",
        "params": map[string]interface{}{
            "prompt":     "Ancient castle under the starry sky",
            "aspect_ratio":       "16:9",
            "resolution": "2K",
            "quality":    "high",
        },
        "out_task_id": "my_task_123456",
    }

    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer <token>")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String url = "https://aireiter.com/api/openapi/submit";

        String payload = """
        {
          "model": "gpt_image_2_official",
          "params": {
            "prompt": "Ancient castle under the starry sky",
            "aspect_ratio": "16:9",
            "resolution": "2K",
            "quality": "high"
          },
          "out_task_id": "my_task_123456"
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer <token>")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

<?php

$url = "https://aireiter.com/api/openapi/submit";

$payload = [
    "model" => "gpt_image_2_official",
    "params" => [
        "prompt" => "Ancient castle under the starry sky",
        "aspect_ratio" => "16:9",
        "resolution" => "2K",
        "quality" => "high"
    ],
    "out_task_id" => "my_task_123456"
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

require 'net/http'
require 'json'
require 'uri'

url = URI("https://aireiter.com/api/openapi/submit")

payload = {
  model: "gpt_image_2_official",
  params: {
    prompt: "Ancient castle under the starry sky",
    aspect_ratio: "16:9",
    resolution: "2K",
    quality: "high"
  },
  out_task_id: "my_task_123456"
}

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 = payload.to_json

response = http.request(request)
puts response.body

import Foundation

let url = URL(string: "https://aireiter.com/api/openapi/submit")!

let payload: [String: Any] = [
    "model": "gpt_image_2_official",
    "params": [
        "prompt": "Ancient castle under the starry sky",
        "aspect_ratio": "16:9",
        "resolution": "2K",
        "quality": "high"
    ],
    "out_task_id": "my_task_123456"
]

var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }

    if let data = data, let responseString = String(data: data, encoding: .utf8) {
        print(responseString)
    }
}

task.resume()

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var url = "https://aireiter.com/api/openapi/submit";

        var payload = @"{
            ""model"": ""gpt_image_2_official"",
            ""params"": {
                ""prompt"": ""Ancient castle under the starry sky"",
                ""aspect_ratio"": ""16:9"",
                ""resolution"": ""2K"",
                ""quality"": ""high""
            },
            ""out_task_id"": ""my_task_123456""
        }";

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");

        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await client.PostAsync(url, content);
        var result = await response.Content.ReadAsStringAsync();

        Console.WriteLine(result);
    }
}

import 'dart:convert';
import 'package:http/http.dart' as http;

void main() async {
  final url = Uri.parse('https://aireiter.com/api/openapi/submit');

  final payload = {
    'model': 'gpt_image_2_official',
    'params': {
      'prompt': 'Ancient castle under the starry sky',
      'aspect_ratio': '16:9',
      'resolution': '2K',
      'quality': 'high',
    },
    'out_task_id': 'my_task_123456',
  };

  final response = await http.post(
    url,
    headers: {
      'Authorization': 'Bearer <token>',
      'Content-Type': 'application/json',
    },
    body: jsonEncode(payload),
  );

  print(response.body);
}

library(httr)
library(jsonlite)

url <- "https://aireiter.com/api/openapi/submit"

payload <- list(
  model = "gpt_image_2_official",
  params = list(
    prompt = "Ancient castle under the starry sky",
    aspect_ratio = "16:9",
    resolution = "2K",
    quality = "high"
  ),
  out_task_id = "my_task_123456"
)

response <- POST(
  url,
  add_headers(
    Authorization = "Bearer <token>",
    `Content-Type` = "application/json"
  ),
  body = toJSON(payload, auto_unbox = TRUE),
  encode = "raw"
)

cat(content(response, "text"))

{
  "code": 200,
  "data": [
    {
      "status": "submitted",
      "task_id": "task_01KPTXXXXXXXXXXXXXXX"
    }
  ]
}

{
  "error": {
    "code": 400,
    "message": "resolution 4K not supported for size 1:1, allowed: 1K / 2K",
    "type": "invalid_request_error"
  }
}

{
  "error": {
    "code": 401,
    "message": "Authentication failed, please check your API key",
    "type": "authentication_error"
  }
}

{
  "error": {
    "code": 402,
    "message": "Insufficient account balance, please recharge and try again",
    "type": "payment_required"
  }
}

{
  "error": {
    "code": 429,
    "message": "Too many requests, please try again later",
    "type": "rate_limit_error"
  }
}

{
  "error": {
    "code": 500,
    "message": "Internal server error, please try again later",
    "type": "server_error"
  }
}

Overview

Image Series

Video Series

Audio Series

Text Series

Task Management

GPT-Image-2 Official Channel Image Generation

Authorizations

Body

Size × Resolution Mapping Table

Response

Query Task Result

Polling Recommendations

​Authorizations

​Body

​Size × Resolution Mapping Table

​Response

​Query Task Result

​Polling Recommendations

Authorizations

Body

Size × Resolution Mapping Table

Response

Query Task Result

Polling Recommendations