> ## Documentation Index
> Fetch the complete documentation index at: https://gccai.heqingsong.uk/llms.txt
> Use this file to discover all available pages before exploring further.

# Seedream-5.0-Flash 图像生成

>  - 异步处理模式，返回任务 ID 用于后续查询
- 支持文生图、图生图、多参考图融合（最多 10 张参考图）
- 独有能力：坐标 / 手绘标记交互编辑、底图 + 最多 16 层的图层拆分
- 支持 1K / 1.5K / 2K 分辨率档位，或 `size` 直接指定精确像素
- 单图模型：每次仅生成 1 张；支持 PNG / JPEG 输出
- 输出图片镜像到平台自有存储并返回平台 URL 

```bash cURL theme={null}
curl --request POST \
  --url https://gccai.heqingsong.uk/v1/images/generations \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "seedream-5-0-flash",
    "prompt": "赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上",
    "size": "16:9",
    "resolution": "2K"
  }'
```

```python Python theme={null}
import requests

url = "https://gccai.heqingsong.uk/v1/images/generations"

payload = {
    "model": "seedream-5-0-flash",
    "prompt": "赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上",
    "size": "16:9",
    "resolution": "2K"
}

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

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

print(response.json())
```

```javascript JavaScript theme={null}
const url = "https://gccai.heqingsong.uk/v1/images/generations";

const payload = {
  model: "seedream-5-0-flash",
  prompt: "赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上",
  size: "16:9",
  resolution: "2K"
};

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));
```

```go Go theme={null}
package main

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

func main() {
    url := "https://gccai.heqingsong.uk/v1/images/generations"

    payload := map[string]interface{}{
        "model":      "seedream-5-0-flash",
        "prompt":     "赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上",
        "size":       "16:9",
        "resolution": "2K",
    }

    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))
}
```

```java Java theme={null}
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://gccai.heqingsong.uk/v1/images/generations";

        String payload = """
        {
          "model": "seedream-5-0-flash",
          "prompt": "赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上",
          "size": "16:9",
          "resolution": "2K"
        }
        """;

        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 PHP theme={null}
<?php

$url = "https://gccai.heqingsong.uk/v1/images/generations";

$payload = [
    "model" => "seedream-5-0-flash",
    "prompt" => "赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上",
    "size" => "16:9",
    "resolution" => "2K"
];

$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;
?>
```

```ruby Ruby theme={null}
require 'net/http'
require 'json'
require 'uri'

url = URI("https://gccai.heqingsong.uk/v1/images/generations")

payload = {
  model: "seedream-5-0-flash",
  prompt: "赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上",
  size: "16:9",
  resolution: "2K"
}

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
```

```swift Swift theme={null}
import Foundation

let url = URL(string: "https://gccai.heqingsong.uk/v1/images/generations")!

let payload: [String: Any] = [
    "model": "seedream-5-0-flash",
    "prompt": "赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上",
    "size": "16:9",
    "resolution": "2K"
]

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()
```

```csharp C# theme={null}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var url = "https://gccai.heqingsong.uk/v1/images/generations";

        var payload = @"{
            ""model"": ""seedream-5-0-flash"",
            ""prompt"": ""赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上"",
            ""size"": ""16:9"",
            ""resolution"": ""2K""
        }";

        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);
    }
}
```

```c C theme={null}
#include <stdio.h>
#include <curl/curl.h>

int main(void) {
    CURL *curl;
    CURLcode res;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        const char *url = "https://gccai.heqingsong.uk/v1/images/generations";
        const char *payload = "{"
            "\"model\":\"seedream-5-0-flash\","
            "\"prompt\":\"赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上\","
            "\"size\":\"16:9\","
            "\"resolution\":\"2K\""
        "}";

        struct curl_slist *headers = NULL;
        headers = curl_slist_append(headers, "Authorization: Bearer <token>");
        headers = curl_slist_append(headers, "Content-Type: application/json");

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

        res = curl_easy_perform(curl);

        if(res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                    curl_easy_strerror(res));
        }

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }

    curl_global_cleanup();
    return 0;
}
```

```objectivec Objective-C theme={null}
#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSURL *url = [NSURL URLWithString:@"https://gccai.heqingsong.uk/v1/images/generations"];

        NSDictionary *payload = @{
            @"model": @"seedream-5-0-flash",
            @"prompt": @"赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上",
            @"size": @"16:9",
            @"resolution": @"2K"
        };

        NSError *error;
        NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
                                                          options:0
                                                            error:&error];

        NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
        [request setHTTPMethod:@"POST"];
        [request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
        [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
        [request setHTTPBody:jsonData];

        NSURLSessionDataTask *task = [[NSURLSession sharedSession]
            dataTaskWithRequest:request
            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                if (error) {
                    NSLog(@"Error: %@", error);
                    return;
                }
                NSString *result = [[NSString alloc] initWithData:data
                                                        encoding:NSUTF8StringEncoding];
                NSLog(@"%@", result);
            }];

        [task resume];
        [[NSRunLoop mainRunLoop] run];
    }
    return 0;
}
```

```ocaml OCaml theme={null}
(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix

let url = "https://gccai.heqingsong.uk/v1/images/generations"

let payload = {|{
  "model": "seedream-5-0-flash",
  "prompt": "赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上",
  "size": "16:9",
  "resolution": "2K"
}|}

let () =
  let headers = Header.init ()
    |> fun h -> Header.add h "Authorization" "Bearer <token>"
    |> fun h -> Header.add h "Content-Type" "application/json"
  in
  let body = Cohttp_lwt.Body.of_string payload in

  let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
    body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
    print_endline body_str
  in
  Lwt_main.run response
```

```dart Dart theme={null}
import 'dart:convert';
import 'package:http/http.dart' as http;

void main() async {
  final url = Uri.parse('https://gccai.heqingsong.uk/v1/images/generations');

  final payload = {
    'model': 'seedream-5-0-flash',
    'prompt': '赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上',
    'size': '16:9',
    'resolution': '2K'
  };

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

  print(response.body);
}
```

```r R theme={null}
library(httr)
library(jsonlite)

url <- "https://gccai.heqingsong.uk/v1/images/generations"

payload <- list(
  model = "seedream-5-0-flash",
  prompt = "赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上",
  size = "16:9",
  resolution = "2K"
)

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

cat(content(response, "text"))
```

```json 200 theme={null}
{
  "code": 200,
  "data": [
    {
      "status": "submitted",
      "task_id": "task_01K8SGYNNNVBQTXNR4MM964S7K"
    }
  ]
}
```

```json 400 theme={null}
{
  "error": {
    "code": 400,
    "message": "请求参数无效",
    "type": "invalid_request_error"
  }
}
```

```json 401 theme={null}
{
  "error": {
    "code": 401,
    "message": "身份验证失败，请检查您的API密钥",
    "type": "authentication_error"
  }
}
```

```json 402 theme={null}
{
  "error": {
    "code": 402,
    "message": "账户余额不足，请充值后再试",
    "type": "payment_required"
  }
}
```

```json 403 theme={null}
{
  "error": {
    "code": 403,
    "message": "访问被禁止，您没有权限访问此资源",
    "type": "permission_error"
  }
}
```

```json 429 theme={null}
{
  "error": {
    "code": 429,
    "message": "请求过于频繁，请稍后再试",
    "type": "rate_limit_error"
  }
}
```

```json 500 theme={null}
{
  "error": {
    "code": 500,
    "message": "服务器内部错误，请稍后重试",
    "type": "server_error"
  }
}
```

```json 502 theme={null}
{
  "error": {
    "code": 502,
    "message": "网关错误，服务器暂时不可用",
    "type": "bad_gateway"
  }
}
```

## Authorizations

**Authorization** `string` *required*

所有接口均需要使用Bearer Token进行认证

获取 API Key：

访问 [API Key 管理页面](https://gccai.heqingsong.uk/keys) 获取您的 API Key

使用时在请求头中添加：

```
Authorization: Bearer YOUR_API_KEY
```

> [!NOTE]
>
> **单图模型**：`seedream-5-0-flash` 每次请求仅生成 1 张图像（图层拆分除外）。以下参数会**直接拒绝**（返回 400，不建任务、不扣费）：
>
> * `n > 1`
> * `sequential_image_generation`（不支持组图）
> * `stream`（不支持流式输出）
> * `tools`（不支持联网搜索）
> * `image_urls` 超过 10 张

> **交互编辑**
>
> 在提示词中使用 `<point>` / `<bbox>` 坐标，或上传带手绘标记的图片，精确指定编辑位置。
>
> * 点选坐标：`<point>x y</point>`（指定一个点，由模型判断影响范围）
> * 框选坐标：`<bbox>x1 y1 x2 y2</bbox>`（指定左上角和右下角坐标，精确控制编辑区域大小）

> **图层拆分**
>
> 将一张图片拆成 1 张底图和最多 16 个透明 PNG 图层，并返回位置与层级信息。

## Body

**model** `string` *required* (default: seedream-5-0-flash)

图像生成模型名称

* `seedream-5-0-flash`（推荐）
* 亦接受：`seedream-5.0-pro`

**nsfw\_check** `boolean` (default: false)

是否在提交图片任务前执行内容审核。

* `true`：使用 `omni-moderation-latest` 审核提示词和输入图片
* `false` 或不传：不发起审核请求，不增加审核成本与延迟（默认）

**prompt** `string` *required*

图像生成的文本描述

使用 `layer_decomposition: true` 时可省略；省略后模型会自动识别并拆分图片中的主要元素。

除中英文外，还支持俄语、阿拉伯语、菲律宾语、泰语、土耳其语、韩语、马来语、西班牙语、葡萄牙语、印度尼西亚语、法语、德语、越南语和日语的原生文字生成。

> **建议：** 控制在 600 英文单词以内，描述过长可能导致细节丢失。

**resolution** `string` (default: 1K)

分辨率档位（兼容小写）。这是本站提供的扩展字段，等价于将档位直接写在 `size` 中。

* `1K`（默认）
* `1.5K`（与 1K **同价**，画质更好，无特殊理由建议优先用 1.5K）
* `2K`

传入 3K / 4K 等不支持档位会返回 400。

同时传入档位形式的 `size` 与 `resolution` 时，以 `size` 为准。

> [!WARNING]
>
> 当 `size` 为**精确像素值**（如 `2048x1024`）时，本字段**被忽略**，尺寸完全由 `size` 决定。

**size** `string` (default: auto)

档位关键字、宽高比、`auto`，或**精确像素值**。

### 写法 ①：指定档位（推荐）

档位可以直接写在 `size` 中，也可以使用本站扩展字段 `resolution`：

```json theme={null}
{ "size": "2K" }
```

```json theme={null}
{ "resolution": "2K" }
```

上面两种写法等价。只指定档位时，可在 prompt 中描述“竖版海报”“横版封面”等用途，由模型决定宽高比。

### 写法 ②：档位 + 宽高比

与 `resolution` 配合使用。支持的宽高比：

* `1:1`、`4:3`、`3:4`、`16:9`、`9:16`、`3:2`、`2:3`、`2:1`、`1:2`、`21:9`
* 兼容 `16x9` 这种 `x` 写法；`2x1` 与 `2:1` 等价，`1x2` 与 `1:2` 等价
* 别名中的 `x` 必须小写，且不能包含空格
* `auto`（默认）：只下发分辨率档位，最终宽高比由模型根据 prompt / 参考图自动判断

列表外的宽高比（如 `9:21`）直接返回 400，**不会静默回退成 1:1**。

**档位 × 比例 → 实际输出像素：**

| 分辨率 | 1:1 | 4:3 | 3:4 | 16:9 | 9:16 | 3:2 | 2:3 | 2:1 | 1:2 | 21:9 |
| - | - | - | - | - | - | - | - | - | - | - |
| **1K** | 1024×1024 | 1152×864 | 864×1152 | 1312×736 | 736×1312 | 1248×832 | 832×1248 | 1440×720 | 720×1440 | 1568×672 |
| **1.5K** | 1536×1536 | 1792×1344 | 1344×1792 | 2048×1152 | 1152×2048 | 1872×1248 | 1248×1872 | 2176×1088 | 1088×2176 | 2352×1008 |
| **2K** | 2048×2048 | 2304×1728 | 1728×2304 | 2560×1440 | 1440×2560 | 2496×1664 | 1664×2496 | 2880×1440 | 1440×2880 | 3024×1296 |

```json theme={null}
{ "resolution": "2K", "size": "2:1" }
```

### 写法 ③：精确像素

`size` 写成 `宽x高` 时**按像素输出**，`resolution` 不参与。兼容 `2048X1024` / `2048×1024`。

| 约束 | 取值 |
| - | - |
| 总像素（宽 × 高） | `[921600, 4624220]`（约 `1280×720` \~ `2048×2048×1.1025`） |
| 宽高比（宽 / 高） | `[1/16, 16]` |

> [!WARNING]
>
> 限制的是**宽高乘积**，不是单边。例如 `512×512` 总像素过低会 400；`2048×1024` 合法。

**background** `string` (default: opaque)

输出背景模式：

* `opaque`：实体背景（默认）
* `transparent`：透明背景

`transparent` 只能用于图生图，并且必须恰好传入 1 张本身带透明通道的输入图；同时必须设置 `output_format: "png"`。

**layer\_decomposition** `boolean` (default: false)

是否进行图层拆分。开启后，模型会输出 1 张底图和最多 16 个带透明通道的 PNG 图层。

开启时必须恰好传入 1 张 PNG 或 JPEG 图片，图片总像素须在 `[262144, 36000000]` 内且大小不超过 30 MB；`size` 只接受 `1K`、`1.5K`、`2K` 或 `auto`，默认 `auto`。`output_format` 只控制底图格式，拆出的图层恒为 PNG。

**optimize\_prompt\_options** `object` (default: \{"mode":"standard"})

提示词优化模式：

* `standard`：标准模式，质量更好（默认）

兼容扁平写法：`"optimize_prompt_options.mode": "standard"`。

**n** `integer` (default: 1)

生成图片数量。只能是 `1`；需要组图生成时请改用 `seedream-5-0-lite`。

**image\_urls** `array`

参考图像的 URL 列表，用于单图 / 多参考图生图，**最多 10 张**

支持两种格式：

**1. 公网 URL**

* `http://` 或 `https://` 可访问链接
* 示例：`https://example.com/image.jpg`

**2. Base64（Data URI）**

* 格式：`data:image/<格式>;base64,<编码>`，`<格式>` **必须小写**
* 示例：`data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABg...`

**单张图片限制：**

* 格式：jpeg / png / webp / bmp / tiff / gif / heic / heif
* 宽高比（宽/高）：`[1/16, 16]`
* 单边 > 14 px
* 大小 ≤ 30 MB
* 总像素 ≤ `6000×6000`（36,000,000）

> **计费：** 第 1 张参考图免费，第 2 张起每张加收固定单价。

**output\_format** `string` (default: jpeg)

输出图片格式

* `jpeg`（默认）
* `png`

> **兼容：** `response_format` 与 `output_format` 等价，其余取值按 `jpeg` 处理。

**watermark** `boolean` (default: false)

是否在生成图像右下角添加 "AI generated" 水印

* `true`：添加
* `false`：不添加（默认）

## 请求示例

### 文生图（档位 + 比例）

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "赛博朋克风格的城市夜景，霓虹灯反射在湿润街道上",
  "resolution": "2K",
  "size": "2:1",
  "output_format": "png"
}
```

### 文生图（精确像素）

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "极简风格电商主图，白底，产品居中",
  "size": "1600x1600"
}
```

### 多参考图

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "将图 1 的服装换为图 2 的服装",
  "image_urls": [
    "https://example.com/person.jpg",
    "https://example.com/dress.jpg"
  ],
  "resolution": "2K",
  "size": "auto"
}
```

### 推荐：1.5K 同价更好画质

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "一只可爱的橘猫坐在窗台上，午后阳光，电影感",
  "resolution": "1.5K",
  "size": "16:9"
}
```

### 图层拆分

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "image_urls": ["https://example.com/poster.png"],
  "layer_decomposition": true,
  "size": "2K"
}
```

也可以使用归一化到 `0–1000` 的 `<bbox>` 坐标精确指定要拆出的元素：

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "将图片进行精确图层分离，文字坐标为<bbox>180 64 812 198</bbox>；鹦鹉坐标为<bbox>347 305 642 997</bbox>。",
  "image_urls": ["https://example.com/poster.png"],
  "layer_decomposition": true
}
```

### 交互编辑

用自然语言描述图片中的手绘标记：

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "根据手绘草图编辑图像。在左下角标记区域添加一叠杂志，在右侧标记区域添加一杯咖啡。移除所有草图线条，保持构图不变。",
  "image_urls": ["https://example.com/sketch.png"],
  "size": "2K",
  "output_format": "png"
}
```

或使用 `<point>` / `<bbox>` 精准定位：

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "将图 1 <bbox>179 283 796 986</bbox> 的主体放到图 2 <bbox>118 331 933 871</bbox> 位置。",
  "image_urls": [
    "https://example.com/a.png",
    "https://example.com/b.png"
  ]
}
```

### 透明通道编辑

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "将鹦鹉改成孔雀，保留透明背景",
  "image_urls": ["https://cdn.example.com/images/layer.png"],
  "background": "transparent",
  "output_format": "png",
  "size": "2K"
}
```

## 完整示例：提交并获取图片

下面的脚本完整展示了提交异步任务、轮询任务状态、处理失败状态并读取最终图片地址的流程。复制前请替换 `YOUR_API_KEY`。

```python Python theme={null}
import time
import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://gccai.heqingsong.uk"
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

# 1. 提交生成任务
create_response = requests.post(
    f"{BASE_URL}/v1/images/generations",
    headers=headers,
    json={
        "model": "seedream-5-0-flash",
        "prompt": "水墨风格的江南小镇，清晨薄雾",
        "resolution": "1.5K",
        "size": "16:9",
        "output_format": "png",
    },
    timeout=30,
)
create_response.raise_for_status()
task_id = create_response.json()["data"][0]["task_id"]
print(f"任务已提交：{task_id}")

# 2. 轮询任务状态
while True:
    task_response = requests.get(
        f"{BASE_URL}/v1/tasks/{task_id}",
        headers=headers,
        timeout=30,
    )
    task_response.raise_for_status()
    task = task_response.json()
    status = task["status"]
    print(f"状态：{status}，进度：{task.get('progress', 0)}%")

    if status == "success":
        image = task["result"]["images"][0]
        print("图片地址：", image["url"][0])
        print("图片尺寸：", image["sizes"][0])
        print("图片格式：", image["output_formats"][0])
        break

    if status in {"failed", "cancelled"}:
        raise RuntimeError(task.get("error", f"任务{status}"))

    time.sleep(5)
```

成功时，任务查询接口返回：

```json theme={null}
{
  "id": "task_01JFXYZ123456789ABCDEF",
  "status": "success",
  "progress": 100,
  "cost": 0.045,
  "result": {
    "images": [
      {
        "url": ["https://cdn.example.com/images/image_task_xxx_0.png"],
        "sizes": ["2048x1152"],
        "output_formats": ["png"],
        "expires_at": 1784696685
      }
    ]
  }
}
```

> [!NOTE]
>
> 返回图片已镜像到平台自有存储。仍建议在业务侧及时下载并持久化，不要把结果 URL 当作永久存储。

## 完整 cURL 场景示例

### 多图融合（最多 10 张参考图）

```bash theme={null}
curl -X POST "https://gccai.heqingsong.uk/v1/images/generations" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-5-0-flash",
    "prompt": "把图 1 的人物放进图 2 的场景，光线统一为黄昏",
    "image_urls": [
      "https://example.com/person.jpg",
      "https://example.com/scene.jpg"
    ],
    "resolution": "1.5K",
    "size": "16:9",
    "output_format": "png"
  }'
```

### 精确像素、提示词优化与水印

```bash theme={null}
curl -X POST "https://gccai.heqingsong.uk/v1/images/generations" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-5-0-flash",
    "prompt": "赛博朋克风格的城市天际线，霓虹灯反射在湿漉漉的街道上",
    "size": "2048x1024",
    "optimize_prompt_options": { "mode": "standard" },
    "watermark": true
  }'
```

### 拆分并单独编辑透明图层

第一步，拆分原图：

```bash theme={null}
curl -X POST "https://gccai.heqingsong.uk/v1/images/generations" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-5-0-flash",
    "image_urls": ["https://example.com/poster.png"],
    "layer_decomposition": true,
    "size": "2K"
  }'
```

第二步，取得某个透明图层的 URL 后单独编辑：

```bash theme={null}
curl -X POST "https://gccai.heqingsong.uk/v1/images/generations" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedream-5-0-flash",
    "prompt": "将图片中的鹦鹉改为孔雀",
    "image_urls": ["https://cdn.example.com/images/image_task_xxx_4.png"],
    "background": "transparent",
    "output_format": "png",
    "size": "2K"
  }'
```

## 图层拆分响应与重组

`url`、`sizes`、`output_formats` 与 `layers` 数组按下标一一对应，下标 `0` 恒为底图：

```json theme={null}
{
  "result": {
    "images": [{
      "url": [
        "https://cdn.example.com/images/image_task_xxx_0.jpeg",
        "https://cdn.example.com/images/image_task_xxx_1.png",
        "https://cdn.example.com/images/image_task_xxx_2.png"
      ],
      "sizes": ["2048x2048", "1273x265", "492x98"],
      "output_formats": ["jpeg", "png", "png"],
      "layer_decomposition": true,
      "layers": [
        { "z_index": 0, "size": "2048x2048", "output_format": "jpeg" },
        {
          "z_index": 1,
          "size": "1273x265",
          "output_format": "png",
          "name": "标题文字",
          "description": "黄色大号衬线字体的标题文字",
          "bounding_box": {
            "absolute": [383, 120, 1655, 384],
            "normalized": [187, 59, 808, 188]
          }
        },
        {
          "z_index": 2,
          "size": "492x98",
          "output_format": "png",
          "name": "左上角标语",
          "description": "白色两行英文标语",
          "bounding_box": {
            "absolute": [140, 451, 631, 548],
            "normalized": [68, 220, 308, 268]
          }
        }
      ]
    }]
  }
}
```

按 `z_index` 从小到大叠放。使用绝对坐标还原到输出底图时：

```text theme={null}
x = left
y = top
w = right - left
h = bottom - top
```

还原到任意 `W × H` 画布时，使用归一化坐标：

```text theme={null}
x = left / 1000 × W
y = top / 1000 × H
w = (right - left) / 1000 × W
h = (bottom - top) / 1000 × H
```

> [!WARNING]
>
> 图层拆分按张收费。提交时按最多 17 张预扣；任务完成后，按每张图片的实际输出像素逐张判档并结算，多扣的自动退回。账户余额必须足以覆盖 17 张预扣；`size: "auto"` 按 2K 档预扣。

## 计费说明

```
总价 = 输出图单价 + 输入参考图加价 × max(0, 参考图张数 − 1)
```

输出图按**每张图片的实际总像素**分档（约 2.61M = 2,601,124）：

| 条件 | 单价 |
| - | - |
| 总像素 ≤ 2.61M（1.5K 及以下：`resolution` 为 `1K` / `1.5K` / 不传，或精确像素 ≤ 2,601,124） | **\$0.045** / 张 |
| 总像素 > 2.61M（高于 1.5K：`resolution: "2K"`，或精确像素 > 2,601,124） | **\$0.09** / 张 |

* **1.5K 与 1K 同价**（均为 \$0.045）。
* `size` 为精确像素时按**实际输出面积**计费，`resolution` 不影响（例如 `size: "2048x2048"` 按 \$0.09）。
* 第 1 张参考图免费，第 2 张起每张另计参考图加价。
* 任务失败自动全额退款。

### 图层拆分的预扣与结算

提交任务时尚不知道最终会生成多少图层及其尺寸，因此按请求参数保守预扣：

* 精确像素：按该像素面积判档。
* `1K` / `1.5K`：按 1K 档预扣。
* `2K`：按 2K 档预扣。
* `auto`：最高可输出到 2K，因此按 2K 档预扣。

任务完成后，以底图和每个实际图层的真实像素面积**逐张判档并求和**，多扣的额度自动退回。图层通常远小于底图，因此即使按 2K 档预扣，最终也可能全部按 1K 档结算。

> [!NOTE]
>
> 例如：一张 `1080×1080` 输入图最终拆成 10 张图片。提交时按 `17 张 × 2K 档` 预扣；如果最终 10 张图片都不超过 261 万像素，则按 `10 张 × 1K 档` 结算，剩余额度自动退回。

## 常见错误

| 场景 | 说明 |
| - | - |
| 不支持的 `resolution` 档位 | 如 3K / 4K → 400 |
| `size` 取值不支持 | 既不是 `1K` / `1.5K` / `2K` / `auto`，也不是支持的宽高比或合法像素值 → 400 |
| 精确像素总像素越界 | 须在 `[921600, 4624220]` |
| 精确像素宽高比越界 | 须在 `[1/16, 16]` |
| `n > 1` / 组图参数 | 单图模型，拒绝 |
| 参考图超过 10 张 | 拒绝 |
| 图层拆分未传图或传入多张图 | 必须恰好传入 1 张图 |
| 图层拆分使用比例或精确像素 | `size` 仅支持 `1K` / `1.5K` / `2K` / `auto` |
| 透明背景用于文生图或多图 | 必须恰好传入 1 张带透明通道的图片 |
| 透明背景与 JPEG 同时使用 | 设置 `output_format: "png"` |
| `stream` / `tools` | 本模型不支持，直接返回 400 |
| 提示词优化模式非法 | 仅支持 `standard` |

> [!NOTE]
>
> ⏱️ **生成较慢**：1K 约 90 秒、2K 约 160 秒（质量优先）。提交后每 5\~10 秒轮询一次 [获取任务状态](https://gccai.heqingsong.uk/cn/api-reference/tasks/status.md)，客户端超时建议 **5 分钟**。请及时保存生成结果。

## Response

**code** `integer`

响应状态码

**data** `array`

返回数据数组

**属性**

**status** `string`

任务状态

* `submitted` - 已提交

**task\_id** `string`

任务唯一标识符


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.