> ## 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 Pembuatan Gambar

>  - Mode pemrosesan asinkron, mengembalikan ID tugas untuk kueri berikutnya
- Mendukung text-to-image, image-to-image satu gambar, dan multi-referensi (maksimal 10 gambar referensi)
- Mendukung tingkat resolusi 1K / 1.5K / 2K, atau piksel tepat melalui `size`
- Model gambar tunggal: satu gambar per permintaan; output PNG / JPEG
- Tautan gambar yang dihasilkan berlaku selama 72 jam; harap segera simpan 

<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": "Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah",
      "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": "Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah",
      "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: "Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah",
    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":     "Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah",
          "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": "Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah",
            "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" => "Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah",
      "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: "Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah",
    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": "Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah",
      "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"": ""Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah"",
              ""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\":\"Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah\","
              "\"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": @"Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah",
              @"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": "Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah",
    "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': 'Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah',
      '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 = "Pemandangan malam kota bergaya cyberpunk, lampu neon memantul di jalanan yang basah",
    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>

## Otorisasi

<ParamField header="Authorization" type="string" required>
  Semua endpoint API memerlukan autentikasi Bearer Token

  Dapatkan API Key Anda:

  Kunjungi [Halaman Manajemen API Key](https://apimart.ai/keys) untuk mendapatkan API Key Anda

  Tambahkan ke header permintaan:

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

<Info>
  **Model gambar tunggal**: `seedream-5-0-flash` hanya menghasilkan 1 gambar per permintaan (kecuali dekomposisi layer). Parameter berikut **ditolak** (HTTP 400, tanpa tugas, tanpa biaya):

  * `n > 1`
  * `sequential_image_generation` (pembuatan grup tidak didukung)
  * `stream` (streaming tidak didukung)
  * `tools` (pencarian web tidak didukung)
  * lebih dari 10 item di `image_urls`
</Info>

<CardGroup cols={2}>
  <Card title="Pengeditan interaktif" icon="crosshairs">
    Gunakan koordinat `<point>` / `<bbox>` dalam prompt, atau unggah gambar dengan anotasi gambar tangan, untuk menentukan lokasi pengeditan secara presisi.

    * Koordinat titik: `<point>x y</point>` (menentukan satu titik; model menentukan area yang terpengaruh)
    * Koordinat kotak pembatas: `<bbox>x1 y1 x2 y2</bbox>` (menentukan koordinat kiri atas dan kanan bawah untuk mengontrol ukuran area pengeditan secara presisi)
  </Card>

  <Card title="Dekomposisi layer" icon="layer-group">
    Pisahkan satu gambar menjadi gambar dasar dan hingga 16 layer PNG transparan, lengkap dengan informasi posisi dan urutan tumpukan.
  </Card>
</CardGroup>

## Body

<ParamField body="model" type="string" default="seedream-5-0-flash" required>
  Nama model pembuatan gambar

  * `seedream-5-0-flash` (direkomendasikan)
  * Juga diterima: `seedream-5.0-pro`
</ParamField>

<ParamField body="nsfw_check" type="boolean" default="false">
  Menentukan apakah moderasi konten dijalankan sebelum tugas gambar dikirim.

  * `true`: periksa prompt dan gambar input dengan `omni-moderation-latest`
  * `false` atau dihilangkan: tidak mengirim permintaan moderasi, tanpa biaya atau latensi moderasi tambahan (default)
</ParamField>

<ParamField body="prompt" type="string" required>
  Deskripsi teks untuk pembuatan gambar

  Opsional ketika `layer_decomposition: true`; jika dihilangkan, model otomatis mengenali dan memisahkan elemen utama dalam gambar.

  Selain bahasa Mandarin dan Inggris, pembuatan teks native mendukung bahasa Rusia, Arab, Filipina, Thai, Turki, Korea, Melayu, Spanyol, Portugis, Indonesia, Prancis, Jerman, Vietnam, dan Jepang.

  > **Tips:** batasi hingga 600 kata bahasa Inggris; deskripsi terlalu panjang dapat kehilangan detail.
</ParamField>

<ParamField body="resolution" type="string" default="1K">
  Tingkat resolusi (huruf kecil diterima). Ini adalah ekstensi API Mart yang setara dengan menuliskan tingkat secara langsung di `size`.

  * `1K` (default)
  * `1.5K` (harga sama dengan 1K, kualitas lebih baik — utamakan 1.5K kecuali ada alasan lain)
  * `2K`

  Tingkat yang tidak didukung seperti 3K / 4K mengembalikan 400.

  Jika `size` berbentuk tingkat dan `resolution` sama-sama diberikan, `size` diprioritaskan.

  <Warning>
    Saat `size` adalah **nilai piksel tepat** (mis. `2048x1024`), bidang ini **diabaikan** dan dimensi hanya dari `size`.
  </Warning>
</ParamField>

<ParamField body="size" type="string" default="auto">
  Kata kunci tingkat, rasio aspek, `auto`, atau **dimensi piksel yang tepat**.

  ### Format ①: tingkat resolusi (disarankan)

  Tingkat dapat dituliskan langsung di `size`, atau diberikan melalui kolom ekstensi API Mart `resolution`:

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

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

  Kedua format ini setara. Jika hanya tingkat yang ditentukan, jelaskan tata letak yang diinginkan dalam prompt (misalnya, "poster potret" atau "sampul lanskap") dan biarkan model memilih rasio aspek.

  ### Format ②: tingkat + rasio aspek

  Digunakan bersama `resolution`. Rasio yang didukung:

  * `1:1`, `4:3`, `3:4`, `16:9`, `9:16`, `3:2`, `2:3`, `2:1`, `1:2`, `21:9`
  * Juga menerima pemisah `x` gaya `16x9`
  * `2x1` setara dengan `2:1`, dan `1x2` setara dengan `1:2`. Huruf `x` harus kecil dan spasi tidak diperbolehkan.
  * `auto` (default): hanya tingkat resolusi; rasio akhir dari prompt / referensi

  Rasio di luar daftar (mis. `9:21`) mengembalikan 400 — **tanpa fallback senyap ke 1:1**.

  **Tingkat × rasio → piksel keluaran:**

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

  ### Format ③: piksel tepat

  Saat `size` adalah `widthxheight`, piksel dipakai apa adanya dan `resolution` tidak berlaku. Menerima `2048X1024` / `2048×1024`.

  | Batasan                       | Rentang                                                        |
  | ----------------------------- | -------------------------------------------------------------- |
  | Total piksel (lebar × tinggi) | `[921600, 4624220]` (sekitar `1280×720` \~ `2048×2048×1.1025`) |
  | Rasio aspek (lebar / tinggi)  | `[1/16, 16]`                                                   |

  <Warning>
    Batas berlaku pada **hasil kali** lebar dan tinggi, bukan tiap sisi sendiri. Contoh: `512×512` terlalu kecil (400); `2048×1024` valid.
  </Warning>
</ParamField>

<ParamField body="background" type="string" default="opaque">
  Mode latar belakang keluaran:

  * `opaque`: latar belakang solid (default)
  * `transparent`: latar belakang transparan

  `transparent` hanya tersedia untuk permintaan gambar-ke-gambar dengan tepat satu gambar input yang sudah memiliki kanal alfa; `output_format: "png"` juga wajib.
</ParamField>

<ParamField body="layer_decomposition" type="boolean" default="false">
  Menentukan apakah gambar akan didekomposisi menjadi layer. Jika diaktifkan, model mengembalikan satu gambar dasar dan hingga 16 layer PNG dengan kanal alfa.

  Diperlukan tepat satu gambar PNG atau JPEG. Jumlah pikselnya harus berada dalam `[262144, 36000000]` dan ukurannya tidak boleh lebih dari 30 MB. `size` hanya menerima `1K`, `1.5K`, `2K`, atau `auto`, dengan default `auto`. `output_format` hanya mengontrol format gambar dasar; layer hasil dekomposisi selalu PNG.
</ParamField>

<ParamField body="optimize_prompt_options" type="object" default={'{"mode":"standard"}'}>
  Mode pengoptimalan prompt:

  * `standard`: mode standar dengan kualitas lebih baik (default)

  Format datar `"optimize_prompt_options.mode": "standard"` juga diterima.
</ParamField>

<ParamField body="n" type="integer" default="1">
  Jumlah gambar yang akan dibuat. Hanya `1` yang didukung; gunakan `seedream-5-0-lite` untuk pembuatan gambar berkelompok.
</ParamField>

<ParamField body="image_urls" type="array">
  Daftar URL gambar referensi untuk image-to-image satu / multi-referensi, **maksimal 10**

  Dua format:

  **1. URL publik**

  * `http://` atau `https://`
  * Contoh: `https://example.com/image.jpg`

  **2. Base64 (Data URI)**

  * Format: `data:image/<format>;base64,<data>` — `<format>` harus **huruf kecil**
  * Contoh: `data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABg...`

  **Batas per gambar:**

  * Format: jpeg / png / webp / bmp / tiff / gif / heic / heif
  * Rasio aspek (l/t): `[1/16, 16]`
  * Tiap sisi > 14 px
  * Ukuran ≤ 30 MB
  * Total piksel ≤ `6000×6000` (36.000.000)

  > **Penagihan:** gambar referensi pertama gratis; setiap gambar tambahan dikenai biaya tetap.
</ParamField>

<ParamField body="output_format" type="string" default="jpeg">
  Format gambar keluaran

  * `jpeg` (default)
  * `png`

  > **Kompatibilitas:** `response_format` setara dengan `output_format`; nilai lain diperlakukan sebagai `jpeg`.
</ParamField>

<ParamField body="watermark" type="boolean" default="false">
  Apakah menambahkan watermark "AI generated" di kanan bawah

  * `true`: tambahkan watermark
  * `false`: tanpa watermark (default)
</ParamField>

## Contoh permintaan

### Text-to-image (tingkat + rasio)

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Pemandangan malam kota cyberpunk, pantulan neon di jalan basah",
  "resolution": "2K",
  "size": "2:1",
  "output_format": "png"
}
```

### Text-to-image (piksel tepat)

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Gambar hero e-commerce minimalis, latar putih, produk di tengah",
  "size": "1600x1600"
}
```

### Multi-referensi

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Ganti pakaian di gambar 1 dengan pakaian di gambar 2",
  "image_urls": [
    "https://example.com/person.jpg",
    "https://example.com/dress.jpg"
  ],
  "resolution": "2K",
  "size": "auto"
}
```

### Direkomendasikan: 1.5K harga sama, kualitas lebih baik

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Kucing oranye lucu di ambang jendela di sinar sore, sinematik",
  "resolution": "1.5K",
  "size": "16:9"
}
```

### Dekomposisi layer

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

Anda juga dapat menggunakan koordinat `<bbox>` yang dinormalisasi ke `0–1000` untuk menentukan elemen yang akan diekstrak secara presisi:

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Pisahkan gambar menjadi layer yang presisi. Teks berada di <bbox>180 64 812 198</bbox>; burung beo berada di <bbox>347 305 642 997</bbox>.",
  "image_urls": ["https://example.com/poster.png"],
  "layer_decomposition": true
}
```

### Pengeditan interaktif

Jelaskan anotasi gambar tangan pada gambar menggunakan bahasa alami:

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Edit gambar sesuai sketsa. Tambahkan setumpuk majalah di area bertanda di kiri bawah dan secangkir kopi di area bertanda di sebelah kanan. Hapus semua garis sketsa dan pertahankan komposisinya.",
  "image_urls": ["https://example.com/sketch.png"],
  "size": "2K",
  "output_format": "png"
}
```

Atau tentukan lokasi dengan tepat menggunakan `<point>` / `<bbox>`:

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Tempatkan subjek dari gambar 1 di <bbox>179 283 796 986</bbox> ke gambar 2 pada posisi <bbox>118 331 933 871</bbox>.",
  "image_urls": [
    "https://example.com/a.png",
    "https://example.com/b.png"
  ]
}
```

### Pengeditan kanal alfa

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Ubah burung beo menjadi merak sambil mempertahankan latar belakang transparan",
  "image_urls": ["https://cdn.example.com/images/layer.png"],
  "background": "transparent",
  "output_format": "png",
  "size": "2K"
}
```

## Contoh lengkap: kirim tugas dan ambil gambar

Skrip berikut menunjukkan alur lengkap: mengirim tugas asinkron, memeriksa statusnya, menangani status kegagalan, dan membaca URL gambar akhir. Ganti `YOUR_API_KEY` sebelum menjalankannya.

```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. Kirim tugas pembuatan
create_response = requests.post(
    f"{BASE_URL}/v1/images/generations",
    headers=headers,
    json={
        "model": "seedream-5-0-flash",
        "prompt": "Kota air Jiangnan bergaya lukisan tinta dengan kabut tipis di pagi hari",
        "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"Tugas dikirim: {task_id}")

# 2. Periksa status tugas
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: {status}; progres: {task.get('progress', 0)}%")

    if status == "success":
        image = task["result"]["images"][0]
        print("URL gambar:", image["url"][0])
        print("Ukuran gambar:", image["sizes"][0])
        print("Format gambar:", image["output_formats"][0])
        break

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

    time.sleep(5)
```

Jika berhasil, endpoint kueri tugas mengembalikan:

```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>
  Gambar yang dikembalikan disalin ke penyimpanan yang dikelola platform. Anda tetap harus segera mengunduh dan menyimpannya secara permanen di sistem sendiri; jangan menganggap URL hasil sebagai penyimpanan permanen.
</Note>

## Skenario cURL lengkap

### Komposisi multi-gambar (hingga 10 referensi)

```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": "Tempatkan orang dari gambar 1 ke dalam adegan gambar 2 dan samakan pencahayaannya menjadi suasana senja",
    "image_urls": [
      "https://example.com/person.jpg",
      "https://example.com/scene.jpg"
    ],
    "resolution": "1.5K",
    "size": "16:9",
    "output_format": "png"
  }'
```

### Piksel tepat, pengoptimalan prompt, dan watermark

```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": "Cakrawala kota cyberpunk dengan lampu neon yang terpantul di jalanan basah",
    "size": "2048x1024",
    "optimize_prompt_options": { "mode": "standard" },
    "watermark": true
  }'
```

### Dekomposisi dan edit layer transparan secara terpisah

Pertama, dekomposisi gambar sumber:

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

Kemudian ambil URL salah satu layer transparan dan edit secara terpisah:

```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": "Ubah burung beo dalam gambar menjadi merak",
    "image_urls": ["https://cdn.example.com/images/image_task_xxx_4.png"],
    "background": "transparent",
    "output_format": "png",
    "size": "2K"
  }'
```

## Respons dan rekonstruksi dekomposisi layer

Array `url`, `sizes`, `output_formats`, dan `layers` saling bersesuaian berdasarkan indeks; indeks `0` selalu merupakan gambar dasar:

```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": "Teks judul",
          "description": "Teks judul kuning besar dengan jenis huruf serif",
          "bounding_box": {
            "absolute": [383, 120, 1655, 384],
            "normalized": [187, 59, 808, 188]
          }
        },
        {
          "z_index": 2,
          "size": "492x98",
          "output_format": "png",
          "name": "Tagline kiri atas",
          "description": "Tagline bahasa Inggris dua baris berwarna putih",
          "bounding_box": {
            "absolute": [140, 451, 631, 548],
            "normalized": [68, 220, 308, 268]
          }
        }
      ]
    }]
  }
}
```

Gabungkan layer dalam urutan `z_index` menaik. Untuk merekonstruksinya pada gambar dasar keluaran dengan koordinat absolut:

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

Untuk merekonstruksinya pada kanvas `W × H` apa pun, gunakan koordinat yang dinormalisasi:

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

<Warning>
  Dekomposisi layer ditagih per gambar. Hingga 17 gambar dipraotorisasi saat tugas dikirim. Setelah selesai, setiap keluaran diberi tingkat berdasarkan jumlah piksel aktual dan diselesaikan secara terpisah; kelebihan praotorisasi dikembalikan otomatis. Saldo Anda harus cukup untuk praotorisasi 17 gambar, dan `size: "auto"` dipraotorisasi pada tingkat 2K.
</Warning>

## Catatan penagihan

```
Total = harga satuan keluaran + biaya tambahan referensi × max(0, jumlah_ref − 1)
```

Keluaran dihargai berdasarkan **total piksel aktual** (\~2.61M = 2,601,124):

| Kondisi                                                                                                                | Harga satuan         |
| ---------------------------------------------------------------------------------------------------------------------- | -------------------- |
| Total piksel ≤ 2.61M (1.5K atau lebih rendah: `resolution` `1K` / `1.5K` / dihilangkan, atau piksel tepat ≤ 2,601,124) | **\$0.045** / gambar |
| Total piksel > 2.61M (lebih tinggi dari 1.5K: `resolution: "2K"`, atau piksel tepat > 2,601,124)                       | **\$0.09** / gambar  |

* **1.5K harganya sama dengan 1K** (\$0.045).
* Dengan piksel tepat di `size`, penagihan memakai **luas keluaran aktual**; `resolution` tidak memengaruhi (mis. `size: "2048x2048"` → \$0.09).
* Gambar referensi pertama gratis; setiap tambahan dikenai biaya.
* Tugas gagal diganti penuh secara otomatis.

### Praotorisasi dan penyelesaian dekomposisi layer

Karena jumlah dan dimensi akhir layer belum diketahui saat tugas dikirim, praotorisasi menggunakan aturan konservatif berdasarkan permintaan:

* Piksel tepat: tingkat ditentukan berdasarkan area piksel yang diminta.
* `1K` / `1.5K`: dipraotorisasi pada tingkat 1K.
* `2K`: dipraotorisasi pada tingkat 2K.
* `auto`: dapat menghasilkan hingga 2K, sehingga dipraotorisasi pada tingkat 2K.

Setelah selesai, gambar dasar dan setiap layer aktual **ditentukan tingkatnya dan dijumlahkan satu per satu** berdasarkan area piksel sebenarnya. Kelebihan praotorisasi dikembalikan otomatis. Layer biasanya jauh lebih kecil daripada gambar dasar, sehingga tugas yang dipraotorisasi pada tingkat 2K pun dapat diselesaikan sepenuhnya pada tingkat 1K.

<Info>
  Contoh: input `1080×1080` didekomposisi menjadi 10 gambar. Tugas dipraotorisasi sebagai `17 gambar × tingkat 2K`. Jika kesepuluh gambar akhir tidak melebihi 2,61 juta piksel, penyelesaian menggunakan `10 gambar × tingkat 1K` dan sisa kredit dikembalikan otomatis.
</Info>

## Kesalahan umum

| Kasus                                                      | Catatan                                                                                                |
| ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| Tingkat `resolution` tidak didukung                        | mis. 3K / 4K → 400                                                                                     |
| Nilai `size` tidak didukung                                | Bukan `1K` / `1.5K` / `2K` / `auto`, rasio aspek yang didukung, maupun dimensi piksel yang valid → 400 |
| Total piksel tepat di luar rentang                         | Harus dalam `[921600, 4624220]`                                                                        |
| Rasio piksel tepat di luar rentang                         | Harus dalam `[1/16, 16]`                                                                               |
| `n > 1` / parameter gambar berkelompok                     | Ditolak oleh model gambar tunggal                                                                      |
| Lebih dari 10 gambar referensi                             | Rejected                                                                                               |
| Dekomposisi layer tanpa gambar atau dengan beberapa gambar | Diperlukan tepat satu gambar                                                                           |
| Dekomposisi layer dengan rasio atau piksel tepat           | `size` hanya mendukung `1K` / `1.5K` / `2K` / `auto`                                                   |
| Latar transparan untuk teks-ke-gambar atau beberapa input  | Diperlukan tepat satu gambar input dengan kanal alfa                                                   |
| Latar transparan dengan JPEG                               | Atur `output_format: "png"`                                                                            |
| `stream` / `tools`                                         | Tidak didukung oleh model ini; mengembalikan 400                                                       |
| Mode pengoptimalan prompt tidak valid                      | Hanya `standard` yang didukung                                                                         |

<Note>
  ⏱️ **Pembuatan lebih lambat**: sekitar 90 detik untuk 1K dan 160 detik untuk 2K (mengutamakan kualitas). Periksa [Status Tugas](/id/api-reference/tasks/status) setiap 5–10 detik dan atur batas waktu klien menjadi **5 menit**. Segera simpan hasil yang dibuat.
</Note>

## Respons

<ResponseField name="code" type="integer">
  Kode status respons
</ResponseField>

<ResponseField name="data" type="array">
  Array data respons

  <Expandable title="Properti">
    <ResponseField name="status" type="string">
      Status tugas

      * `submitted` - Dikirim
    </ResponseField>

    <ResponseField name="task_id" type="string">
      Pengidentifikasi unik tugas
    </ResponseField>
  </Expandable>
</ResponseField>