Image Generation

根据文本描述生成高质量图片。

POST /v1/images/generations

gpt-image-2 文本生成图片

Curl

curl https://gw.opentoken.io/v1/images/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPEN_TOKEN_KEY" \
  -d '{
  "model": "gpt-image-2",
  "prompt": "一只穿着宇航服的柴犬在月球上奔跑，数字艺术风格",
  "size": "1024x1024",
  "quality": "low",
  "output_format": "png",
  "n": 1
}'

Python

import os
import requests

response = requests.post(
    "https://gw.opentoken.io/v1/images/generations",
    headers={
        "Authorization": f"Bearer {os.environ['OPEN_TOKEN_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "gpt-image-2",
        "prompt": "一只穿着宇航服的柴犬在月球上奔跑，数字艺术风格",
        "size": "1024x1024",
        "quality": "low",
        "output_format": "png",
        "n": 1,
    },
)
response.raise_for_status()
print(response.json())

TypeScript

const apiKey = process.env.OPEN_TOKEN_KEY;
if (!apiKey) {
  throw new Error("OPEN_TOKEN_KEY is not set");
}

const response = await fetch("https://gw.opentoken.io/v1/images/generations", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "gpt-image-2",
    prompt: "一只穿着宇航服的柴犬在月球上奔跑，数字艺术风格",
    size: "1024x1024",
    quality: "low",
    output_format: "png",
    n: 1,
  }),
});
if (!response.ok) {
  throw new Error(`Request failed: ${response.status} ${response.statusText}`);
}
console.log(await response.json());

Java

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

public class ImageGeneration {
    public static void main(String[] args) throws Exception {
        String apiKey = System.getenv("OPEN_TOKEN_KEY");
        if (apiKey == null || apiKey.isBlank()) {
            throw new IllegalStateException("OPEN_TOKEN_KEY is not set");
        }

        String json = "{"
            + "\"model\":\"gpt-image-2\","
            + "\"prompt\":\"一只穿着宇航服的柴犬在月球上奔跑，数字艺术风格\","
            + "\"size\":\"1024x1024\","
            + "\"quality\":\"low\","
            + "\"output_format\":\"png\","
            + "\"n\":1"
            + "}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://gw.opentoken.io/v1/images/generations"))
            .header("Authorization", "Bearer " + apiKey)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(json))
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() < 200 || response.statusCode() >= 300) {
            throw new IllegalStateException("Request failed: " + response.statusCode() + " " + response.body());
        }
        System.out.println(response.body());
    }
}

Go

package main

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

func main() {
    apiKey := os.Getenv("OPEN_TOKEN_KEY")
    if apiKey == "" {
        panic("OPEN_TOKEN_KEY is not set")
    }

    payload := map[string]interface{}{
        "model": "gpt-image-2",
        "prompt": "一只穿着宇航服的柴犬在月球上奔跑，数字艺术风格",
        "size": "1024x1024",
        "quality": "low",
        "output_format": "png",
        "n": 1,
    }
    body, err := json.Marshal(payload)
    if err != nil {
        panic(err)
    }

    request, err := http.NewRequest(
        http.MethodPost,
        "https://gw.opentoken.io/v1/images/generations",
        bytes.NewReader(body),
    )
    if err != nil {
        panic(err)
    }
    request.Header.Set("Authorization", "Bearer "+apiKey)
    request.Header.Set("Content-Type", "application/json")

    response, err := http.DefaultClient.Do(request)
    if err != nil {
        panic(err)
    }
    defer response.Body.Close()
    responseBody, _ := io.ReadAll(response.Body)
    if response.StatusCode < 200 || response.StatusCode >= 300 {
        panic(fmt.Sprintf("request failed: %s: %s", response.Status, responseBody))
    }
    fmt.Println(string(responseBody))
}

PHP

<?php

$apiKey = getenv('OPEN_TOKEN_KEY');
if (!$apiKey) {
    throw new RuntimeException('OPEN_TOKEN_KEY is not set');
}

$ch = curl_init('https://gw.opentoken.io/v1/images/generations');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'model' => 'gpt-image-2',
        'prompt' => '一只穿着宇航服的柴犬在月球上奔跑，数字艺术风格',
        'size' => '1024x1024',
        'quality' => 'low',
        'output_format' => 'png',
        'n' => 1,
    ], JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR),
]);

$body = curl_exec($ch);
if ($body === false) {
    throw new RuntimeException(curl_error($ch));
}
$statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($statusCode < 200 || $statusCode >= 300) {
    throw new RuntimeException("Request failed: $statusCode $body");
}
echo $body, PHP_EOL;

Ruby

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

api_key = ENV.fetch('OPEN_TOKEN_KEY')
uri = URI('https://gw.opentoken.io/v1/images/generations')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri.request_uri)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'
request.body = {
  model: 'gpt-image-2',
  prompt: '一只穿着宇航服的柴犬在月球上奔跑，数字艺术风格',
  size: '1024x1024',
  quality: 'low',
  output_format: 'png',
  n: 1,
}.to_json

response = http.request(request)
unless response.is_a?(Net::HTTPSuccess)
  raise "Request failed: #{response.code} #{response.body}"
end
puts response.body

C#

using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

var apiKey = Environment.GetEnvironmentVariable("OPEN_TOKEN_KEY");
if (string.IsNullOrWhiteSpace(apiKey))
{
    throw new InvalidOperationException("OPEN_TOKEN_KEY is not set");
}

using var client = new HttpClient();
using var request = new HttpRequestMessage(
    HttpMethod.Post,
    "https://gw.opentoken.io/v1/images/generations");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
request.Content = new StringContent(JsonSerializer.Serialize(new
{
    model = "gpt-image-2",
    prompt = "一只穿着宇航服的柴犬在月球上奔跑，数字艺术风格",
    size = "1024x1024",
    quality = "low",
    output_format = "png",
    n = 1,
}), Encoding.UTF8, "application/json");

using var response = await client.SendAsync(request);
var body = await response.Content.ReadAsStringAsync();
response.EnsureSuccessStatusCode();
Console.WriteLine(body);

size 用于选择输出尺寸，quality 用于选择图片生成质量档位。quality 不是通用的推理强度参数。

请求参数

参数	类型	必填	默认值	描述
model	string	是	gpt-image-2	模型 ID，本页示例使用 gpt-image-2
prompt	string	是	-	描述所需图像的文本
size	string	否	1024x1024	输出尺寸：1024x1024 / 1536x1024 / 1024x1536 / 2048x2048 / auto
quality	string	否	low	图像质量：low / medium / high / auto
n	integer	否	1	生成数量
background	string	否	-	背景处理：auto / opaque
output_format	string	否	png	输出图片格式：png / jpeg / webp

响应结构 — Base64

{
  "created": 1717800000,
  "data": [
    {
      "b64_json": "iVBORw0KGgoAAAANSUhEUgAA...",
      "revised_prompt": "一只穿着宇航服的柴犬..."
    }
  ]
}

响应结构 — URL

{
  "created": 1717800000,
  "data": [
    {
      "url": "https://cdn.opentoken.io/images/gen_abc123.png",
      "revised_prompt": "一只穿着宇航服的柴犬..."
    }
  ]
}