curl --request POST \
  --url https://api.apimart.ai/v1/images/generations \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "gpt-image-2-official",
    "prompt": "An ancient castle beneath a starry sky",
    "size": "16:9",
    "resolution": "2k",
    "quality": "high",
    "n": 1
  }'

import requests

url = "https://api.apimart.ai/v1/images/generations"

payload = {
    "model": "gpt-image-2-official",
    "prompt": "An ancient castle beneath a starry sky",
    "size": "16:9",
    "resolution": "2k",
    "quality": "high",
    "n": 1
}

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

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

print(response.json())

const url = "https://api.apimart.ai/v1/images/generations";

const payload = {
  model: "gpt-image-2-official",
  prompt: "An ancient castle beneath a starry sky",
  size: "16:9",
  resolution: "2k",
  quality: "high",
  n: 1,
};

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://api.apimart.ai/v1/images/generations"

    payload := map[string]interface{}{
        "model":      "gpt-image-2-official",
        "prompt":     "An ancient castle beneath a starry sky",
        "size":       "16:9",
        "resolution": "2k",
        "quality":    "high",
        "n":          1,
    }

    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://api.apimart.ai/v1/images/generations";

        String payload = """
        {
          "model": "gpt-image-2-official",
          "prompt": "An ancient castle beneath a starry sky",
          "size": "16:9",
          "resolution": "2k",
          "quality": "high",
          "n": 1
        }
        """;

        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://api.apimart.ai/v1/images/generations";

$payload = [
    "model" => "gpt-image-2-official",
    "prompt" => "An ancient castle beneath a starry sky",
    "size" => "16:9",
    "resolution" => "2k",
    "quality" => "high",
    "n" => 1
];

$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://api.apimart.ai/v1/images/generations")

payload = {
  model: "gpt-image-2-official",
  prompt: "An ancient castle beneath a starry sky",
  size: "16:9",
  resolution: "2k",
  quality: "high",
  n: 1
}

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://api.apimart.ai/v1/images/generations")!

let payload: [String: Any] = [
    "model": "gpt-image-2-official",
    "prompt": "An ancient castle beneath a starry sky",
    "size": "16:9",
    "resolution": "2k",
    "quality": "high",
    "n": 1
]

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://api.apimart.ai/v1/images/generations";

        var payload = @"{
            ""model"": ""gpt-image-2-official"",
            ""prompt"": ""An ancient castle beneath a starry sky"",
            ""size"": ""16:9"",
            ""resolution"": ""2k"",
            ""quality"": ""high"",
            ""n"": 1
        }";

        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://api.apimart.ai/v1/images/generations');

  final payload = {
    'model': 'gpt-image-2-official',
    'prompt': 'An ancient castle beneath a starry sky',
    'size': '16:9',
    'resolution': '2k',
    'quality': 'high',
    'n': 1,
  };

  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://api.apimart.ai/v1/images/generations"

payload <- list(
  model = "gpt-image-2-official",
  prompt = "An ancient castle beneath a starry sky",
  size = "16:9",
  resolution = "2k",
  quality = "high",
  n = 1
)

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": "Invalid parameters: size not allowed / resolution not supported / pixel violation, etc.",
    "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 top up and try again",
    "type": "payment_required"
  }
}

{
  "error": {
    "code": 403,
    "message": "Access forbidden, you do not have permission to access this resource",
    "type": "permission_error"
  }
}

{
  "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"
  }
}

{
  "error": {
    "code": 502,
    "message": "Bad gateway, the server is temporarily unavailable",
    "type": "bad_gateway"
  }
}

GPT-Image-2

Geração de imagens GPT-Image-2 Canal Oficial

Modelo oficial gpt-image-2 da OpenAI, baseado no protocolo compatível /v1/images/generations
Processamento assíncrono, retorna task_id para consultas posteriores
Texto para imagem / imagem para imagem / inpainting (máscara) — tudo em um
Suporte a fundos transparentes em PNG / WebP (canal alfa)
Novo campo de nível resolution — escolha entre 1K / 2K / 4K
15 proporções suportadas nos níveis 1K / 2K / 4K
Até 4 imagens por requisição, até 16 imagens de referência
95% de alinhamento de parâmetros com gpt-image-1.5-official — migração requer apenas a alteração do nome do modelo

POST

images

generations

curl --request POST \
  --url https://api.apimart.ai/v1/images/generations \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "gpt-image-2-official",
    "prompt": "An ancient castle beneath a starry sky",
    "size": "16:9",
    "resolution": "2k",
    "quality": "high",
    "n": 1
  }'

import requests

url = "https://api.apimart.ai/v1/images/generations"

payload = {
    "model": "gpt-image-2-official",
    "prompt": "An ancient castle beneath a starry sky",
    "size": "16:9",
    "resolution": "2k",
    "quality": "high",
    "n": 1
}

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

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

print(response.json())

const url = "https://api.apimart.ai/v1/images/generations";

const payload = {
  model: "gpt-image-2-official",
  prompt: "An ancient castle beneath a starry sky",
  size: "16:9",
  resolution: "2k",
  quality: "high",
  n: 1,
};

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://api.apimart.ai/v1/images/generations"

    payload := map[string]interface{}{
        "model":      "gpt-image-2-official",
        "prompt":     "An ancient castle beneath a starry sky",
        "size":       "16:9",
        "resolution": "2k",
        "quality":    "high",
        "n":          1,
    }

    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://api.apimart.ai/v1/images/generations";

        String payload = """
        {
          "model": "gpt-image-2-official",
          "prompt": "An ancient castle beneath a starry sky",
          "size": "16:9",
          "resolution": "2k",
          "quality": "high",
          "n": 1
        }
        """;

        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://api.apimart.ai/v1/images/generations";

$payload = [
    "model" => "gpt-image-2-official",
    "prompt" => "An ancient castle beneath a starry sky",
    "size" => "16:9",
    "resolution" => "2k",
    "quality" => "high",
    "n" => 1
];

$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://api.apimart.ai/v1/images/generations")

payload = {
  model: "gpt-image-2-official",
  prompt: "An ancient castle beneath a starry sky",
  size: "16:9",
  resolution: "2k",
  quality: "high",
  n: 1
}

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://api.apimart.ai/v1/images/generations")!

let payload: [String: Any] = [
    "model": "gpt-image-2-official",
    "prompt": "An ancient castle beneath a starry sky",
    "size": "16:9",
    "resolution": "2k",
    "quality": "high",
    "n": 1
]

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://api.apimart.ai/v1/images/generations";

        var payload = @"{
            ""model"": ""gpt-image-2-official"",
            ""prompt"": ""An ancient castle beneath a starry sky"",
            ""size"": ""16:9"",
            ""resolution"": ""2k"",
            ""quality"": ""high"",
            ""n"": 1
        }";

        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://api.apimart.ai/v1/images/generations');

  final payload = {
    'model': 'gpt-image-2-official',
    'prompt': 'An ancient castle beneath a starry sky',
    'size': '16:9',
    'resolution': '2k',
    'quality': 'high',
    'n': 1,
  };

  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://api.apimart.ai/v1/images/generations"

payload <- list(
  model = "gpt-image-2-official",
  prompt = "An ancient castle beneath a starry sky",
  size = "16:9",
  resolution = "2k",
  quality = "high",
  n = 1
)

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": "Invalid parameters: size not allowed / resolution not supported / pixel violation, etc.",
    "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 top up and try again",
    "type": "payment_required"
  }
}

{
  "error": {
    "code": 403,
    "message": "Access forbidden, you do not have permission to access this resource",
    "type": "permission_error"
  }
}

{
  "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"
  }
}

{
  "error": {
    "code": 502,
    "message": "Bad gateway, the server is temporarily unavailable",
    "type": "bad_gateway"
  }
}

curl --request POST \
  --url https://api.apimart.ai/v1/images/generations \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "gpt-image-2-official",
    "prompt": "An ancient castle beneath a starry sky",
    "size": "16:9",
    "resolution": "2k",
    "quality": "high",
    "n": 1
  }'

import requests

url = "https://api.apimart.ai/v1/images/generations"

payload = {
    "model": "gpt-image-2-official",
    "prompt": "An ancient castle beneath a starry sky",
    "size": "16:9",
    "resolution": "2k",
    "quality": "high",
    "n": 1
}

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

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

print(response.json())

const url = "https://api.apimart.ai/v1/images/generations";

const payload = {
  model: "gpt-image-2-official",
  prompt: "An ancient castle beneath a starry sky",
  size: "16:9",
  resolution: "2k",
  quality: "high",
  n: 1,
};

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://api.apimart.ai/v1/images/generations"

    payload := map[string]interface{}{
        "model":      "gpt-image-2-official",
        "prompt":     "An ancient castle beneath a starry sky",
        "size":       "16:9",
        "resolution": "2k",
        "quality":    "high",
        "n":          1,
    }

    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://api.apimart.ai/v1/images/generations";

        String payload = """
        {
          "model": "gpt-image-2-official",
          "prompt": "An ancient castle beneath a starry sky",
          "size": "16:9",
          "resolution": "2k",
          "quality": "high",
          "n": 1
        }
        """;

        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://api.apimart.ai/v1/images/generations";

$payload = [
    "model" => "gpt-image-2-official",
    "prompt" => "An ancient castle beneath a starry sky",
    "size" => "16:9",
    "resolution" => "2k",
    "quality" => "high",
    "n" => 1
];

$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://api.apimart.ai/v1/images/generations")

payload = {
  model: "gpt-image-2-official",
  prompt: "An ancient castle beneath a starry sky",
  size: "16:9",
  resolution: "2k",
  quality: "high",
  n: 1
}

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://api.apimart.ai/v1/images/generations")!

let payload: [String: Any] = [
    "model": "gpt-image-2-official",
    "prompt": "An ancient castle beneath a starry sky",
    "size": "16:9",
    "resolution": "2k",
    "quality": "high",
    "n": 1
]

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://api.apimart.ai/v1/images/generations";

        var payload = @"{
            ""model"": ""gpt-image-2-official"",
            ""prompt"": ""An ancient castle beneath a starry sky"",
            ""size"": ""16:9"",
            ""resolution"": ""2k"",
            ""quality"": ""high"",
            ""n"": 1
        }";

        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://api.apimart.ai/v1/images/generations');

  final payload = {
    'model': 'gpt-image-2-official',
    'prompt': 'An ancient castle beneath a starry sky',
    'size': '16:9',
    'resolution': '2k',
    'quality': 'high',
    'n': 1,
  };

  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://api.apimart.ai/v1/images/generations"

payload <- list(
  model = "gpt-image-2-official",
  prompt = "An ancient castle beneath a starry sky",
  size = "16:9",
  resolution = "2k",
  quality = "high",
  n = 1
)

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": "Invalid parameters: size not allowed / resolution not supported / pixel violation, etc.",
    "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 top up and try again",
    "type": "payment_required"
  }
}

{
  "error": {
    "code": 403,
    "message": "Access forbidden, you do not have permission to access this resource",
    "type": "permission_error"
  }
}

{
  "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"
  }
}

{
  "error": {
    "code": 502,
    "message": "Bad gateway, the server is temporarily unavailable",
    "type": "bad_gateway"
  }
}

Autorizações

string

obrigatório

Todos os endpoints requerem autenticação por Bearer TokenObtenha sua chave de API:Acesse a página de gerenciamento de chaves de API para obter sua chave de APIInclua-a no cabeçalho da requisição:

Authorization: Bearer YOUR_API_KEY

Body

string

padrão:"gpt-image-2-official"

obrigatório

Nome do modelo de geração de imagensFixo em gpt-image-2-official (modelo oficial gpt-image-2 da OpenAI)

boolean

padrão:"false"

Define se o conteúdo deve ser moderado antes do envio da tarefa de imagem.

true: verificar prompts e imagens de entrada com omni-moderation-latest
false ou omitido: não enviar solicitação de moderação, sem custo nem latência adicionais de moderação (padrão)

string

obrigatório

Descrição textual para a geração da imagem

Suporta inglês e chinês, descrições detalhadas são recomendadas
Moderação de conteúdo / revisão de segurança antes do envio — violações são rejeitadas imediatamente

string

padrão:"1:1"

Proporção da imagemExternamente, usa valores de proporção; internamente, é mapeada para pixels reais de acordo com resolution.Proporções suportadas, além de auto para deixar o servidor escolher uma proporção adequada automaticamente:

auto - Automático (o servidor escolhe uma proporção com base no prompt / imagens de referência)
1:1 - Quadrado (padrão, avatares de redes sociais / logos)
3:2 - Paisagem (proporção comum de DSLR)
2:3 - Retrato (pôsteres verticais)
4:3 - Paisagem (monitor clássico / apresentação de slides)
3:4 - Retrato
5:4 - Paisagem
4:5 - Retrato (post vertical do Instagram)
16:9 - Paisagem (miniatura de vídeo widescreen)
9:16 - Retrato (tela cheia do celular / capa de vídeo curto)
2:1 - Paisagem (banner web)
1:2 - Retrato
3:1 - Paisagem (banner ultrawide)
1:3 - Retrato (pôster extra alto)
21:9 - Paisagem (ultrawide cinematográfico)
9:21 - Retrato

Dimensões em pixels também podem ser passadas diretamente, como 1881x836 / 887x1774.

Quando size é definido como auto, a proporção padrão é 1:1.

string

padrão:"1k"

Nível de resolução (novo campo)Controla a nitidez real da saída.

1k - Linha de base 1024, custo-eficiente para uso diário (padrão)
2k - Linha de base 2048, adequado para pôsteres / necessidades de alta definição
4k - Linha de base 3840, suporta as 15 proporções na tabela de mapeamento abaixo

O 4K suporta as 15 proporções na tabela de mapeamento abaixo; você também pode passar as dimensões em pixels da tabela diretamente via size.

string

padrão:"auto"

Qualidade da imagem

auto - Automático (padrão, normalmente equivalente a low)
low - Rápido e econômico, suficiente para esboços
medium - Balanceado
high - Precisão máxima (4K + high pode levar mais de 120s)

string

padrão:"auto"

Modo de fundo

auto - Automático (padrão)
opaque - Opaco
transparent - Solicita um fundo transparente; a saída inclui um canal alfa

string

padrão:"auto"

Intensidade da moderação

auto - Intensidade de moderação padrão
low - Moderação mais permissiva

string

padrão:"png"

Formato de saída

png - Formato padrão, suporta fundos transparentes
jpeg - Arquivos menores, não suporta canal alfa
webp - Suporta fundos transparentes, adequado para navegadores modernos

Quando background for transparent, apenas png ou webp poderão ser selecionados.

integer

Nível de compressão de saída, intervalo 0-100

Eficaz apenas para jpeg / webp

integer

padrão:"1"

Número de imagens a serem geradasIntervalo: 1 ~ 4

Deve ser um número puro (ex.: 1), não envolva em aspas

array

Array de URLs de imagens de referência

Mostrar Detalhes

Máximo de 20 MB por imagem, limite total de 256 MB
Até 16 imagens de referência; mais serão rejeitadas
Devem ser URLs de imagens publicamente acessíveis e estáveis

string

URL da imagem de máscara, usada para inpainting

Deve ser usada em conjunto com image_urls

Certifique-se de que a imagem de máscara tenha um canal Alpha antes de fazer o upload.
As dimensões da imagem de máscara devem coincidir com a primeira imagem de referência.

Mapeamento Size × Resolution

size × resolution → pixels reais da OpenAI (15 proporções × 3 níveis):

size	`1k`	`2k`	`4k`
`1:1`	1024×1024	2048×2048	2880×2880
`3:2`	1536×1024	2048×1360	3520×2336
`2:3`	1024×1536	1360×2048	2336×3520
`4:3`	1024×768	2048×1536	3312×2480
`3:4`	768×1024	1536×2048	2480×3312
`5:4`	1280×1024	2560×2048	3216×2576
`4:5`	1024×1280	2048×2560	2576×3216
`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
`3:1`	1881×836 / 1536×512	3072×1024	3840×1280
`1:3`	887×1774 / 512×1536	1024×3072	1280×3840
`21:9`	2016×864	2688×1152	3840×1648
`9:21`	864×2016	1152×2688	1648×3840

Observação: Algumas dimensões são aproximadas com base em múltiplos de 16 e limites de pixel, como 3:2 / 2:3 @ 2K sendo 2048×1360 e 21:9 @ 4K sendo 3840×1648. Use os pixels reais da tabela como fonte da verdade.

Exemplos de uso

Texto para imagem (requisição mínima)

{
  "model": "gpt-image-2-official",
  "prompt": "An ancient castle beneath a starry sky"
}

Texto para imagem (adesivo com fundo transparente)

{
  "model": "gpt-image-2-official",
  "prompt": "A cute cartoon orange cat sticker, full body, thick white outline, flat vector style, isolated on a fully transparent background",
  "size": "1:1",
  "resolution": "1k",
  "quality": "medium",
  "background": "transparent",
  "output_format": "png",
  "n": 1
}

Imagem para imagem (remover o fundo)

{
  "model": "gpt-image-2-official",
  "prompt": "Remove the background, keep only the product, isolated on a fully transparent background",
  "image_urls": ["https://your-cdn.com/product.jpg"],
  "size": "1:1",
  "resolution": "1k",
  "background": "transparent",
  "output_format": "png"
}

Pôster em 2K de alta definição

{
  "model": "gpt-image-2-official",
  "prompt": "Cyberpunk night scene",
  "size": "16:9",
  "resolution": "2k",
  "quality": "high",
  "output_format": "jpeg",
  "output_compression": 90
}

Wallpaper em 4K

{
  "model": "gpt-image-2-official",
  "prompt": "Snow mountain sunrise panorama",
  "size": "16:9",
  "resolution": "4k",
  "quality": "high",
  "n": 1
}

Imagem para imagem (fusão de múltiplas referências)

{
  "model": "gpt-image-2-official",
  "prompt": "Fuse the two reference images into a single illustration poster, preserving the main silhouettes",
  "size": "1:1",
  "quality": "high",
  "image_urls": [
    "https://your-cdn.com/input-a.png",
    "https://your-cdn.com/input-b.png"
  ]
}

Inpainting (máscara)

{
  "model": "gpt-image-2-official",
  "prompt": "Replace the background with a desert sunset",
  "size": "1:1",
  "quality": "medium",
  "image_urls": ["https://your-cdn.com/photo.png"],
  "mask_url": "https://your-cdn.com/mask.png"
}

Múltiplas imagens (n > 1)

{
  "model": "gpt-image-2-official",
  "prompt": "Four minimalist poster variations of a red fox",
  "size": "1:1",
  "quality": "low",
  "n": 4
}

String de pixels direta (avançado)

{
  "model": "gpt-image-2-official",
  "prompt": "wide cinematic shot",
  "size": "3840x2160",
  "quality": "high"
}

Response

integer

Código de status da resposta

array

Array de dados da resposta

Mostrar Propriedades

string

Status da tarefa

submitted - Enviada

string

Identificador único da tarefa, usado para consultas posteriores de resultados

Consulta de resultados da tarefa

Após o envio bem-sucedido, um task_id é retornado. Consulte o status da tarefa via GET /v1/tasks/{task_id}, veja API de consulta de tarefas para mais detalhes.

Exemplo de resposta de sucesso

{
  "code": 200,
  "data": {
    "actual_time": 14,
    "completed": 1784607890,
    "cost": 0.004792,
    "created": 1784607876,
    "credits_cost": 0.047920000000000004,
    "estimated_time": 60,
    "id": "task_01KPTXXXXXXXXXXXXXXX",
    "progress": 100,
    "result": {
      "images": [
        {
          "expires_at": 1784694290,
          "url": [
            "https://upload.apimart.ai/f/image/xxxxxxxx-gpt_image_2_official_task_xxx_0.png"
          ]
        }
      ]
    },
    "status": "completed",
    "usage": {
      "input_tokens": 22,
      "input_tokens_details": {
        "cached_tokens": 0,
        "image_tokens": 0,
        "text_tokens": 22
      },
      "output_tokens": 196,
      "output_tokens_details": {
        "image_tokens": 196,
        "text_tokens": 0
      },
      "total_tokens": 218
    }
  }
}

O campo usage indica o consumo de tokens cobrado nesta requisição:

Campo	Descrição
`input_tokens`	Total de tokens de entrada consumidos
`input_tokens_details.cached_tokens`	Tokens de entrada servidos a partir do cache
`input_tokens_details.image_tokens`	Tokens usados pelas imagens de entrada
`input_tokens_details.text_tokens`	Tokens usados pelo texto de entrada (prompt)
`output_tokens`	Total de tokens de saída consumidos
`output_tokens_details.image_tokens`	Tokens usados pela imagem gerada
`output_tokens_details.text_tokens`	Tokens usados pelo texto de saída
`total_tokens`	Total de tokens, igual a `input_tokens` + `output_tokens`

Na geração de imagens a saída é composta principalmente por tokens de imagem, portanto output_tokens_details.image_tokens costuma ser igual a output_tokens. No exemplo acima, total_tokens = 22 + 196 = 218. Fluxo de status da tarefa: submitted → in_progress → completed / failed. Acesso à imagem: data.result.images[0].url[0].

Visão Geral

Modelos

Série de Texto

Série de Imagem

Série de Vídeo

Série de Áudio

Série de Moderação

Gerenciamento de Upload

Gerenciamento de Tarefas

Gerenciamento de Conta

Geração de imagens GPT-Image-2 Canal Oficial

Autorizações

Body

Mapeamento Size × Resolution

Exemplos de uso

Response

Consulta de resultados da tarefa

Exemplo de resposta de sucesso

​Autorizações

​Body

​Mapeamento Size × Resolution

​Exemplos de uso

​Response

​Consulta de resultados da tarefa

​Exemplo de resposta de sucesso

Autorizações

Body

Mapeamento Size × Resolution

Exemplos de uso

Response

Consulta de resultados da tarefa

Exemplo de resposta de sucesso