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

# Генерация изображений Seedream-5.0-Flash

>  - Асинхронный режим обработки, возвращает идентификатор задачи для последующих запросов
- Поддерживает text-to-image, image-to-image с одним изображением и с несколькими референсными изображениями (до 10)
- Поддерживает уровни разрешения 1K / 1.5K / 2K или точные пиксели через `size`
- Модель одиночного изображения: 1 изображение за запрос; вывод PNG / JPEG
- Ссылки на сгенерированные изображения действительны в течение 72 часов, своевременно сохраняйте их 

<RequestExample>
  ```bash cURL theme={null}
  curl --request POST \
    --url https://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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"))
  ```
</RequestExample>

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

  ```json 400 theme={null}
  {
    "error": {
      "code": 400,
      "message": "Invalid request parameters",
      "type": "invalid_request_error"
    }
  }
  ```

  ```json 401 theme={null}
  {
    "error": {
      "code": 401,
      "message": "Invalid authentication credentials",
      "type": "authentication_error"
    }
  }
  ```

  ```json 402 theme={null}
  {
    "error": {
      "code": 402,
      "message": "Insufficient balance. Please top up your account",
      "type": "payment_required"
    }
  }
  ```

  ```json 403 theme={null}
  {
    "error": {
      "code": 403,
      "message": "Access forbidden. You don't have permission to access this resource",
      "type": "permission_error"
    }
  }
  ```

  ```json 429 theme={null}
  {
    "error": {
      "code": 429,
      "message": "Rate limit exceeded. Please try again later",
      "type": "rate_limit_error"
    }
  }
  ```

  ```json 500 theme={null}
  {
    "error": {
      "code": 500,
      "message": "Internal server error. Please try again later",
      "type": "server_error"
    }
  }
  ```

  ```json 502 theme={null}
  {
    "error": {
      "code": 502,
      "message": "Bad gateway. The server is temporarily unavailable",
      "type": "bad_gateway"
    }
  }
  ```
</ResponseExample>

## Авторизация

<ParamField header="Authorization" type="string" required>
  Все конечные точки API требуют аутентификации Bearer Token

  Получите свой API Key:

  Перейдите на [страницу управления API ключами](https://apimart.ai/keys), чтобы получить свой API Key

  Добавьте его в заголовок запроса:

  ```
  Authorization: Bearer YOUR_API_KEY
  ```
</ParamField>

<Info>
  **Модель одиночных изображений**: `seedream-5-0-flash` создаёт только 1 изображение за запрос (кроме декомпозиции на слои). Следующие параметры **отклоняются** (HTTP 400, задача не создаётся, оплата не списывается):

  * `n > 1`
  * `sequential_image_generation` (групповая генерация не поддерживается)
  * `stream` (потоковая передача не поддерживается)
  * `tools` (веб-поиск не поддерживается)
  * более 10 элементов в `image_urls`
</Info>

<CardGroup cols={2}>
  <Card title="Интерактивное редактирование" icon="crosshairs">
    Используйте координаты `<point>` / `<bbox>` в промпте или загрузите изображение с рукописными пометками, чтобы точно указать область редактирования.

    * Координаты точки: `<point>x y</point>` (задают одну точку; модель определяет область воздействия)
    * Координаты ограничивающей рамки: `<bbox>x1 y1 x2 y2</bbox>` (задают координаты левого верхнего и правого нижнего углов для точного управления размером области редактирования)
  </Card>

  <Card title="Декомпозиция на слои" icon="layer-group">
    Разделите одно изображение на базовое изображение и до 16 прозрачных PNG-слоёв с данными о позиции и порядке наложения.
  </Card>
</CardGroup>

## Тело запроса

<ParamField body="model" type="string" default="seedream-5-0-flash" required>
  Название модели генерации изображений

  * `seedream-5-0-flash` (рекомендуется)
  * Также принимается: `seedream-5.0-pro`
</ParamField>

<ParamField body="nsfw_check" type="boolean" default="false">
  Выполнять ли проверку содержимого перед отправкой задачи генерации изображения.

  * `true`: проверить промпты и входные изображения с помощью `omni-moderation-latest`
  * `false` или параметр не указан: не отправлять запрос на проверку, без дополнительных затрат и задержки (по умолчанию)
</ParamField>

<ParamField body="prompt" type="string" required>
  Текстовое описание для генерации изображения

  Необязателен при `layer_decomposition: true`; если опущен, модель автоматически определит и разделит основные элементы изображения.

  Помимо китайского и английского, нативная генерация текста поддерживает русский, арабский, филиппинский, тайский, турецкий, корейский, малайский, испанский, португальский, индонезийский, французский, немецкий, вьетнамский и японский языки.

  > **Совет:** не более 600 английских слов; слишком длинное описание может привести к потере деталей.
</ParamField>

<ParamField body="resolution" type="string" default="1K">
  Уровень разрешения (допускается нижний регистр). Это расширение API Mart, эквивалентное прямому указанию уровня в `size`.

  * `1K` (по умолчанию)
  * `1.5K` (та же цена, что у 1K, лучше качество — предпочтительно 1.5K, если нет причин иначе)
  * `2K`

  Неподдерживаемые уровни, например 3K / 4K, возвращают 400.

  Если одновременно заданы `size` в виде уровня и `resolution`, приоритет имеет `size`.

  <Warning>
    Когда `size` — **точное значение в пикселях** (например `2048x1024`), это поле **игнорируется**, размеры берутся только из `size`.
  </Warning>
</ParamField>

<ParamField body="size" type="string" default="auto">
  Ключевое слово уровня, соотношение сторон, `auto` или **точные размеры в пикселях**.

  ### Формат ①: уровень разрешения (рекомендуется)

  Уровень можно указать непосредственно в `size` или через поле расширения API Mart `resolution`:

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

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

  Эти форматы эквивалентны. Если задан только уровень, опишите желаемую компоновку в промпте (например, "вертикальный плакат" или "горизонтальная обложка") и позвольте модели выбрать соотношение сторон.

  ### Формат ②: уровень + соотношение сторон

  Используется с `resolution`. Поддерживаемые соотношения:

  * `1:1`, `4:3`, `3:4`, `16:9`, `9:16`, `3:2`, `2:3`, `2:1`, `1:2`, `21:9`
  * Также принимается разделитель `x` в стиле `16x9`
  * `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` — `widthxheight`, пиксели используются как есть, `resolution` не применяется. Принимаются `2048X1024` / `2048×1024`.

  | Ограничение                          | Диапазон                                                        |
  | ------------------------------------ | --------------------------------------------------------------- |
  | Всего пикселей (ширина × высота)     | `[921600, 4624220]` (примерно `1280×720` \~ `2048×2048×1.1025`) |
  | Соотношение сторон (ширина / высота) | `[1/16, 16]`                                                    |

  <Warning>
    Ограничения применяются к **произведению** ширины и высоты, а не к каждой стороне отдельно. Пример: `512×512` слишком мало (400); `2048×1024` допустимо.
  </Warning>
</ParamField>

<ParamField body="background" type="string" default="opaque">
  Режим фона выходного изображения:

  * `opaque`: непрозрачный фон (по умолчанию)
  * `transparent`: прозрачный фон

  `transparent` доступен только для запросов image-to-image с ровно одним входным изображением, уже содержащим альфа-канал; также требуется `output_format: "png"`.
</ParamField>

<ParamField body="layer_decomposition" type="boolean" default="false">
  Указывает, нужно ли разложить изображение на слои. При включении модель возвращает одно базовое изображение и до 16 PNG-слоёв с альфа-каналами.

  Требуется ровно одно изображение PNG или JPEG. Оно должно содержать от `[262144, 36000000]` пикселей и иметь размер не более 30 МБ. `size` принимает только `1K`, `1.5K`, `2K` или `auto`; по умолчанию — `auto`. `output_format` управляет только форматом базового изображения; слои всегда возвращаются в PNG.
</ParamField>

<ParamField body="optimize_prompt_options" type="object" default={'{"mode":"standard"}'}>
  Режим оптимизации промпта:

  * `standard`: стандартный режим с лучшим качеством (по умолчанию)

  Также принимается плоская форма `"optimize_prompt_options.mode": "standard"`.
</ParamField>

<ParamField body="n" type="integer" default="1">
  Число создаваемых изображений. Поддерживается только `1`; для групповой генерации используйте `seedream-5-0-lite`.
</ParamField>

<ParamField body="image_urls" type="array">
  Список URL референсных изображений для image-to-image с одним / несколькими референсами, **до 10**

  Два формата:

  **1. Публичный URL**

  * `http://` или `https://`
  * Пример: `https://example.com/image.jpg`

  **2. Base64 (Data URI)**

  * Формат: `data:image/<format>;base64,<data>` — `<format>` должен быть **в нижнем регистре**
  * Пример: `data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABg...`

  **Ограничения на одно изображение:**

  * Форматы: jpeg / png / webp / bmp / tiff / gif / heic / heif
  * Соотношение сторон (w/h): `[1/16, 16]`
  * Каждая сторона > 14 px
  * Размер ≤ 30 MB
  * Всего пикселей ≤ `6000×6000` (36,000,000)

  > **Тарификация:** первое референсное изображение бесплатно; каждое дополнительное — фиксированная доплата.
</ParamField>

<ParamField body="output_format" type="string" default="jpeg">
  Формат выходного изображения

  * `jpeg` (по умолчанию)
  * `png`

  > **Совместимость:** `response_format` эквивалентен `output_format`; прочие значения обрабатываются как `jpeg`.
</ParamField>

<ParamField body="watermark" type="boolean" default="false">
  Добавлять ли водяной знак "AI generated" в правом нижнем углу

  * `true`: добавить водяной знак
  * `false`: без водяного знака (по умолчанию)
</ParamField>

## Примеры запросов

### Text-to-image (уровень + соотношение)

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Киберпанк ночной город, неон отражается на мокрых улицах",
  "resolution": "2K",
  "size": "2:1",
  "output_format": "png"
}
```

### Text-to-image (точные пиксели)

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Минималистичный e-commerce hero, белый фон, товар по центру",
  "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"
}
```

Также можно использовать координаты `<bbox>`, нормализованные к `0–1000`, чтобы точно указать извлекаемые элементы:

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

## Полный пример: отправка задачи и получение изображения

Скрипт ниже показывает полный цикл: отправку асинхронной задачи, опрос её статуса, обработку ошибок и чтение итогового URL изображения. Перед запуском замените `YOUR_API_KEY`.

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

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.apimart.ai"
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("URL изображения:", 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)
```

При успехе endpoint запроса задачи возвращает:

```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 результата постоянным хранилищем.
</Note>

## Полные сценарии cURL

### Композиция из нескольких изображений (до 10 референсов)

```bash theme={null}
curl -X POST "https://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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://api.apimart.ai/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.
</Warning>

## Примечания по тарификации

```
Итого = цена за выход + надбавка за референсы × 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).
* Первое референс-изображение бесплатно; каждое следующее — с надбавкой.
* При сбое задачи — полный автоматический возврат.

### Предавторизация и расчёт декомпозиции на слои

Поскольку при отправке задачи конечное число и размеры слоёв неизвестны, предавторизация использует консервативные правила по параметрам запроса:

* Точные пиксели: уровень по запрошенной площади в пикселях.
* `1K` / `1.5K`: предавторизация на уровне 1K.
* `2K`: предавторизация на уровне 2K.
* `auto`: может выводить до 2K, поэтому предавторизуется на уровне 2K.

После завершения базовое изображение и каждый фактический слой **отдельно классифицируются и суммируются** по реальной площади в пикселях. Излишек предавторизации возвращается автоматически. Слои обычно намного меньше базового изображения, поэтому даже задача, предавторизованная на уровне 2K, может полностью рассчитаться на уровне 1K.

<Info>
  Пример: вход `1080×1080` разлагается на 10 изображений. Задача предавторизуется как `17 изображений × уровень 2K`. Если все 10 итоговых изображений содержат не более 2,61 млн пикселей, расчёт идёт как `10 изображений × уровень 1K`, а остаток средств возвращается автоматически.
</Info>

## Типичные ошибки

| Случай                                                       | Примечания                                                                                                      |
| ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
| Неподдерживаемый уровень `resolution`                        | напр. 3K / 4K → 400                                                                                             |
| Неподдерживаемое значение `size`                             | Не `1K` / `1.5K` / `2K` / `auto`, не поддерживаемое соотношение сторон и не допустимые размеры в пикселях → 400 |
| Сумма точных пикселей вне диапазона                          | Должно быть в `[921600, 4624220]`                                                                               |
| Соотношение точных пикселей вне диапазона                    | Должно быть в `[1/16, 16]`                                                                                      |
| `n > 1` / параметры групповых изображений                    | Отклоняется моделью одиночных изображений                                                                       |
| Более 10 референсных изображений                             | Rejected                                                                                                        |
| Декомпозиция без изображения или с несколькими изображениями | Требуется ровно одно изображение                                                                                |
| Декомпозиция с соотношением сторон или точными пикселями     | `size` поддерживает только `1K` / `1.5K` / `2K` / `auto`                                                        |
| Прозрачный фон для text-to-image или нескольких входов       | Требуется ровно одно входное изображение с альфа-каналом                                                        |
| Прозрачный фон с JPEG                                        | Установите `output_format: "png"`                                                                               |
| `stream` / `tools`                                           | Не поддерживается этой моделью; возвращает 400                                                                  |
| Недопустимый режим оптимизации промпта                       | Поддерживается только `standard`                                                                                |

<Note>
  ⏱️ **Более медленная генерация**: около 90 с для 1K и 160 с для 2K (приоритет качества). Опрашивайте [статус задачи](/ru/api-reference/tasks/status) каждые 5–10 секунд и установите тайм-аут клиента на **5 минут**. Своевременно сохраняйте созданные результаты.
</Note>

## Ответ

<ResponseField name="code" type="integer">
  Код состояния ответа
</ResponseField>

<ResponseField name="data" type="array">
  Массив данных ответа

  <Expandable title="Свойства">
    <ResponseField name="status" type="string">
      Статус задачи

      * `submitted` — отправлено
    </ResponseField>

    <ResponseField name="task_id" type="string">
      Уникальный идентификатор задачи
    </ResponseField>
  </Expandable>
</ResponseField>