> ## 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.

# Génération d'images Seedream-5.0-Flash

>  - Mode de traitement asynchrone, retourne un identifiant de tâche pour les requêtes ultérieures
- Prend en charge texte-vers-image, image-vers-image simple et multi-références (jusqu'à 10 images de référence)
- Prend en charge les niveaux de résolution 1K / 1.5K / 2K, ou des pixels exacts via `size`
- Modèle image unique : une image par requête ; sortie PNG / JPEG
- Les liens des images générées sont valides 72 heures, veuillez les enregistrer rapidement 

<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": "Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées",
      "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": "Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées",
      "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: "Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées",
    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":     "Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées",
          "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": "Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées",
            "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" => "Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées",
      "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: "Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées",
    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": "Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées",
      "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"": ""Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées"",
              ""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\":\"Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées\","
              "\"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": @"Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées",
              @"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": "Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées",
    "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': 'Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées',
      '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 = "Paysage urbain nocturne de style cyberpunk, néons se reflétant sur les rues mouillées",
    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>

## Autorisations

<ParamField header="Authorization" type="string" required>
  Tous les points de terminaison de l'API nécessitent une authentification Bearer Token

  Obtenez votre clé API :

  Visitez la [page de gestion des clés API](https://apimart.ai/keys) pour obtenir votre clé API

  Ajoutez-la à l'en-tête de la requête :

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

<Info>
  **Modèle à image unique** : `seedream-5-0-flash` ne génère qu'une image par requête (sauf lors de la décomposition en calques). Les paramètres suivants sont **refusés** (HTTP 400, aucune tâche, aucun frais) :

  * `n > 1`
  * `sequential_image_generation` (la génération groupée n'est pas prise en charge)
  * `stream` (le streaming n'est pas pris en charge)
  * `tools` (la recherche web n'est pas prise en charge)
  * plus de 10 éléments dans `image_urls`
</Info>

<CardGroup cols={2}>
  <Card title="Édition interactive" icon="crosshairs">
    Utilisez des coordonnées `<point>` / `<bbox>` dans le prompt, ou chargez une image annotée à la main, afin de cibler précisément les modifications.

    * Coordonnées d'un point : `<point>x y</point>` (indiquent un point unique ; le modèle détermine la zone affectée)
    * Coordonnées d'un cadre : `<bbox>x1 y1 x2 y2</bbox>` (indiquent les coordonnées du coin supérieur gauche et du coin inférieur droit afin de contrôler précisément la taille de la zone d'édition)
  </Card>

  <Card title="Décomposition en calques" icon="layer-group">
    Décomposez une image en une image de base et jusqu'à 16 calques PNG transparents, avec leurs informations de position et d'empilement.
  </Card>
</CardGroup>

## Body

<ParamField body="model" type="string" default="seedream-5-0-flash" required>
  Nom du modèle de génération d'images

  * `seedream-5-0-flash` (recommandé)
  * Également accepté : `seedream-5.0-pro`
</ParamField>

<ParamField body="nsfw_check" type="boolean" default="false">
  Indique s'il faut modérer le contenu avant d'envoyer la tâche d'image.

  * `true` : vérifier les prompts et les images d'entrée avec `omni-moderation-latest`
  * `false` ou omis : ne pas envoyer de requête de modération, sans coût ni latence de modération supplémentaires (par défaut)
</ParamField>

<ParamField body="prompt" type="string" required>
  Description textuelle pour la génération d'images

  Facultatif lorsque `layer_decomposition: true` ; s'il est omis, le modèle identifie et sépare automatiquement les principaux éléments de l'image.

  Outre le chinois et l'anglais, la génération native de texte prend en charge le russe, l'arabe, le filipino, le thaï, le turc, le coréen, le malais, l'espagnol, le portugais, l'indonésien, le français, l'allemand, le vietnamien et le japonais.

  > **Conseil :** restez sous 600 mots anglais ; une description trop longue peut entraîner une perte de détails.
</ParamField>

<ParamField body="resolution" type="string" default="1K">
  Palier de résolution (minuscules acceptées). Il s'agit d'une extension API Mart équivalente à l'indication directe du palier dans `size`.

  * `1K` (par défaut)
  * `1.5K` (même prix que 1K, meilleure qualité — préférez 1.5K sauf raison contraire)
  * `2K`

  Les niveaux non pris en charge tels que 3K / 4K renvoient 400.

  Si `size` sous forme de palier et `resolution` sont tous deux fournis, `size` est prioritaire.

  <Warning>
    Lorsque `size` est une **valeur pixel exacte** (ex. `2048x1024`), ce champ est **ignoré** et les dimensions proviennent uniquement de `size`.
  </Warning>
</ParamField>

<ParamField body="size" type="string" default="auto">
  Un mot-clé de palier, un format d'image, `auto` ou des **dimensions exactes en pixels**.

  ### Syntaxe ① : palier de résolution (recommandé)

  Le palier peut être indiqué directement dans `size` ou via le champ d'extension API Mart `resolution` :

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

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

  Ces deux syntaxes sont équivalentes. Si seul un palier est indiqué, décrivez la mise en page souhaitée dans le prompt (par exemple, "affiche en portrait" ou "couverture en paysage") et laissez le modèle choisir le format d'image.

  ### Syntaxe ② : palier + format d'image

  Utilisé avec `resolution`. Rapports pris en charge :

  * `1:1`, `4:3`, `3:4`, `16:9`, `9:16`, `3:2`, `2:3`, `2:1`, `1:2`, `21:9`
  * Accepte aussi le séparateur `x` style `16x9`
  * `2x1` équivaut à `2:1` et `1x2` à `1:2`. Le `x` doit être en minuscule et les espaces ne sont pas acceptés.
  * `auto` (par défaut) : seul le niveau de résolution s'applique ; le rapport final est choisi d'après le prompt / les références

  Les rapports hors liste (ex. `9:21`) renvoient 400 — **pas de repli silencieux vers 1:1**.

  **Niveau × rapport → pixels de sortie :**

  | Résolution | 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" }
  ```

  ### Syntaxe ③ : pixels exacts

  Lorsque `size` est `widthxheight`, les pixels sont utilisés tels quels et `resolution` ne s'applique pas. Accepte `2048X1024` / `2048×1024`.

  | Contrainte                           | Plage                                                          |
  | ------------------------------------ | -------------------------------------------------------------- |
  | Pixels totaux (largeur × hauteur)    | `[921600, 4624220]` (environ `1280×720` \~ `2048×2048×1.1025`) |
  | Rapport d'aspect (largeur / hauteur) | `[1/16, 16]`                                                   |

  <Warning>
    Les limites s'appliquent au **produit** largeur × hauteur, pas à chaque côté seul. Exemple : `512×512` est trop petit (400) ; `2048×1024` est valide.
  </Warning>
</ParamField>

<ParamField body="background" type="string" default="opaque">
  Mode d'arrière-plan de sortie :

  * `opaque`: arrière-plan opaque (par défaut)
  * `transparent`: arrière-plan transparent

  `transparent` n'est disponible que pour les requêtes image-vers-image comportant exactement une image d'entrée qui possède déjà un canal alpha ; `output_format: "png"` est également requis.
</ParamField>

<ParamField body="layer_decomposition" type="boolean" default="false">
  Indique s'il faut décomposer l'image en calques. Lorsque cette option est activée, le modèle renvoie une image de base et jusqu'à 16 calques PNG avec canal alpha.

  Une seule image PNG ou JPEG est requise. Elle doit contenir entre `[262144, 36000000]` pixels au total et ne pas dépasser 30 Mo. `size` n'accepte que `1K`, `1.5K`, `2K` ou `auto`, avec `auto` par défaut. `output_format` ne contrôle que le format de l'image de base ; les calques décomposés sont toujours au format PNG.
</ParamField>

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

  * `standard`: mode standard offrant une meilleure qualité (par défaut)

  La syntaxe aplatie `"optimize_prompt_options.mode": "standard"` est également acceptée.
</ParamField>

<ParamField body="n" type="integer" default="1">
  Nombre d'images à générer. Seule la valeur `1` est prise en charge ; utilisez `seedream-5-0-lite` pour la génération groupée d'images.
</ParamField>

<ParamField body="image_urls" type="array">
  Liste d'URL d'images de référence pour image-to-image simple / multi-références, **jusqu'à 10**

  Deux formats :

  **1. URL publique**

  * `http://` ou `https://`
  * Exemple : `https://example.com/image.jpg`

  **2. Base64 (Data URI)**

  * Format : `data:image/<format>;base64,<data>` — `<format>` doit être en **minuscules**
  * Exemple : `data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABg...`

  **Limites par image :**

  * Formats : jpeg / png / webp / bmp / tiff / gif / heic / heif
  * Rapport d'aspect (l/h) : `[1/16, 16]`
  * Chaque côté > 14 px
  * Taille ≤ 30 Mo
  * Pixels totaux ≤ `6000×6000` (36 000 000)

  > **Facturation :** première image de référence gratuite ; chaque image supplémentaire a un supplément fixe.
</ParamField>

<ParamField body="output_format" type="string" default="jpeg">
  Format de l'image de sortie

  * `jpeg` (par défaut)
  * `png`

  > **Compatibilité :** `response_format` est équivalent à `output_format` ; les autres valeurs sont traitées comme `jpeg`.
</ParamField>

<ParamField body="watermark" type="boolean" default="false">
  Ajouter ou non un filigrane « AI generated » en bas à droite

  * `true` : ajouter le filigrane
  * `false` : pas de filigrane (par défaut)
</ParamField>

## Exemples de requêtes

### Texte-vers-image (niveau + rapport)

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Scène urbaine cyberpunk de nuit, reflets néon sur rues mouillées",
  "resolution": "2K",
  "size": "2:1",
  "output_format": "png"
}
```

### Texte-vers-image (pixels exacts)

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Image hero e-commerce minimaliste, fond blanc, produit centré",
  "size": "1600x1600"
}
```

### Multi-références

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Remplacer la tenue de l'image 1 par la tenue de l'image 2",
  "image_urls": [
    "https://example.com/person.jpg",
    "https://example.com/dress.jpg"
  ],
  "resolution": "2K",
  "size": "auto"
}
```

### Recommandé : 1.5K même prix, meilleure qualité

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Un mignon chat orange sur un rebord de fenêtre au soleil de l'après-midi, cinématique",
  "resolution": "1.5K",
  "size": "16:9"
}
```

### Décomposition en calques

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

Vous pouvez aussi utiliser des coordonnées `<bbox>` normalisées sur `0–1000` afin d'identifier précisément les éléments à extraire :

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Sépare l'image en calques précis. Le texte se trouve dans <bbox>180 64 812 198</bbox> ; le perroquet dans <bbox>347 305 642 997</bbox>.",
  "image_urls": ["https://example.com/poster.png"],
  "layer_decomposition": true
}
```

### Édition interactive

Décrivez en langage naturel les annotations dessinées à la main dans l'image :

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Modifie l'image en suivant le croquis. Ajoute une pile de magazines dans la zone marquée en bas à gauche et une tasse de café dans la zone marquée à droite. Supprime tous les traits du croquis et conserve la composition.",
  "image_urls": ["https://example.com/sketch.png"],
  "size": "2K",
  "output_format": "png"
}
```

Ou ciblez précisément les emplacements avec `<point>` / `<bbox>` :

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Place le sujet de l'image 1 situé dans <bbox>179 283 796 986</bbox> dans l'image 2 à l'emplacement <bbox>118 331 933 871</bbox>.",
  "image_urls": [
    "https://example.com/a.png",
    "https://example.com/b.png"
  ]
}
```

### Édition du canal alpha

```json theme={null}
{
  "model": "seedream-5-0-flash",
  "prompt": "Transforme le perroquet en paon tout en conservant l'arrière-plan transparent",
  "image_urls": ["https://cdn.example.com/images/layer.png"],
  "background": "transparent",
  "output_format": "png",
  "size": "2K"
}
```

## Exemple complet : envoyer une tâche et récupérer l'image

Le script suivant illustre le flux complet : envoyer une tâche asynchrone, interroger son état, gérer les échecs et lire l'URL finale de l'image. Remplacez `YOUR_API_KEY` avant de l'exécuter.

```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. Envoyer la tâche de génération
create_response = requests.post(
    f"{BASE_URL}/v1/images/generations",
    headers=headers,
    json={
        "model": "seedream-5-0-flash",
        "prompt": "Une ville d'eau du Jiangnan au style lavis, dans une légère brume matinale",
        "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"Tâche envoyée : {task_id}")

# 2. Interroger l'état de la tâche
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"État : {status} ; progression : {task.get('progress', 0)} %")

    if status == "success":
        image = task["result"]["images"][0]
        print("URL de l'image :", image["url"][0])
        print("Dimensions de l'image :", image["sizes"][0])
        print("Format de l'image :", image["output_formats"][0])
        break

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

    time.sleep(5)
```

En cas de réussite, l'endpoint de consultation de la tâche renvoie :

```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>
  Les images renvoyées sont répliquées dans un stockage géré par la plateforme. Téléchargez-les et conservez-les néanmoins rapidement dans votre propre système ; ne considérez pas l'URL du résultat comme un stockage permanent.
</Note>

## Scénarios cURL complets

### Composition multi-image (jusqu'à 10 références)

```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": "Place la personne de l'image 1 dans la scène de l'image 2 et harmonise l'éclairage au crépuscule",
    "image_urls": [
      "https://example.com/person.jpg",
      "https://example.com/scene.jpg"
    ],
    "resolution": "1.5K",
    "size": "16:9",
    "output_format": "png"
  }'
```

### Pixels exacts, optimisation du prompt et filigrane

```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": "Une silhouette urbaine cyberpunk avec des néons se reflétant sur les rues mouillées",
    "size": "2048x1024",
    "optimize_prompt_options": { "mode": "standard" },
    "watermark": true
  }'
```

### Décomposer et modifier séparément un calque transparent

Commencez par décomposer l'image source :

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

Récupérez ensuite l'URL d'un calque transparent et modifiez-le séparément :

```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": "Transforme le perroquet de l'image en paon",
    "image_urls": ["https://cdn.example.com/images/image_task_xxx_4.png"],
    "background": "transparent",
    "output_format": "png",
    "size": "2K"
  }'
```

## Réponse de décomposition en calques et reconstruction

Les tableaux `url`, `sizes`, `output_formats` et `layers` se correspondent par indice ; l'indice `0` représente toujours l'image de base :

```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": "Texte du titre",
          "description": "Grand texte de titre jaune en police à empattements",
          "bounding_box": {
            "absolute": [383, 120, 1655, 384],
            "normalized": [187, 59, 808, 188]
          }
        },
        {
          "z_index": 2,
          "size": "492x98",
          "output_format": "png",
          "name": "Slogan en haut à gauche",
          "description": "Slogan anglais blanc sur deux lignes",
          "bounding_box": {
            "absolute": [140, 451, 631, 548],
            "normalized": [68, 220, 308, 268]
          }
        }
      ]
    }]
  }
}
```

Superposez les calques dans l'ordre croissant de `z_index`. Pour les reconstruire sur l'image de base de sortie avec des coordonnées absolues :

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

Pour les reconstruire sur n'importe quel canevas `W × H`, utilisez les coordonnées normalisées :

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

<Warning>
  La décomposition en calques est facturée par image. Jusqu'à 17 images sont préautorisées lors de l'envoi de la tâche. Une fois la tâche terminée, chaque sortie est classée selon son nombre réel de pixels et facturée séparément ; tout excédent de préautorisation est remboursé automatiquement. Votre solde doit couvrir la préautorisation de 17 images et `size: "auto"` est préautorisé au palier 2K.
</Warning>

## Notes de facturation

```
Total = prix unitaire de sortie + majoration références × max(0, nb_réfs − 1)
```

La sortie est tarifée selon le **nombre total de pixels réel** (\~2.61M = 2,601,124) :

| Condition                                                                                               | Prix unitaire       |
| ------------------------------------------------------------------------------------------------------- | ------------------- |
| Pixels totaux ≤ 2.61M (1.5K ou moins : `resolution` `1K` / `1.5K` / omis, ou pixels exacts ≤ 2,601,124) | **\$0.045** / image |
| Pixels totaux > 2.61M (au-dessus de 1.5K : `resolution: "2K"`, ou pixels exacts > 2,601,124)            | **\$0.09** / image  |

* **1.5K au même prix que 1K** (\$0.045).
* Avec des pixels exacts dans `size`, la facturation suit la **surface de sortie réelle** ; `resolution` n'intervient pas (ex. `size: "2048x2048"` → \$0.09).
* La 1ʳᵉ image de référence est gratuite ; chaque image suivante a une majoration.
* Les tâches en échec sont intégralement remboursées.

### Préautorisation et facturation de la décomposition en calques

Le nombre et les dimensions finales des calques étant inconnus à l'envoi de la tâche, la préautorisation applique des règles prudentes fondées sur la requête :

* Pixels exacts : palier déterminé par la surface demandée en pixels.
* `1K` / `1.5K` : préautorisation au palier 1K.
* `2K` : préautorisation au palier 2K.
* `auto` : pouvant produire jusqu'à 2K, il est préautorisé au palier 2K.

Après exécution, l'image de base et chaque calque réel sont **classés et additionnés individuellement** selon leur surface réelle en pixels. L'excédent de préautorisation est remboursé automatiquement. Les calques sont généralement bien plus petits que l'image de base ; une tâche préautorisée au palier 2K peut donc être entièrement facturée au palier 1K.

<Info>
  Exemple : une entrée `1080×1080` est décomposée en 10 images. La tâche est préautorisée pour `17 images × palier 2K`. Si les 10 images finales ne dépassent pas 2,61 millions de pixels, la facturation porte sur `10 images × palier 1K` et le crédit restant est remboursé automatiquement.
</Info>

## Erreurs courantes

| Cas                                                                 | Notes                                                                                                            |
| ------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| Niveau `resolution` non pris en charge                              | ex. 3K / 4K → 400                                                                                                |
| Valeur `size` non prise en charge                                   | Ni `1K` / `1.5K` / `2K` / `auto`, ni un format d'image pris en charge, ni des dimensions en pixels valides → 400 |
| Total pixels exacts hors plage                                      | Doit être dans `[921600, 4624220]`                                                                               |
| Rapport pixels exacts hors plage                                    | Doit être dans `[1/16, 16]`                                                                                      |
| `n > 1` / paramètres d'images groupées                              | Refusé par le modèle à image unique                                                                              |
| Plus de 10 images de référence                                      | Rejected                                                                                                         |
| Décomposition sans image ou avec plusieurs images                   | Une seule image est requise                                                                                      |
| Décomposition avec un format ou des pixels exacts                   | `size` ne prend en charge que `1K` / `1.5K` / `2K` / `auto`                                                      |
| Arrière-plan transparent pour texte-vers-image ou entrées multiples | Une seule image d'entrée avec canal alpha est requise                                                            |
| Arrière-plan transparent avec JPEG                                  | Définissez `output_format: "png"`                                                                                |
| `stream` / `tools`                                                  | Non pris en charge par ce modèle ; renvoie 400                                                                   |
| Mode d'optimisation du prompt non valide                            | Seul `standard` est pris en charge                                                                               |

<Note>
  ⏱️ **Génération plus lente** : environ 90 s en 1K et 160 s en 2K (priorité à la qualité). Interrogez [l'état de la tâche](/fr/api-reference/tasks/status) toutes les 5 à 10 secondes et réglez le délai du client sur **5 minutes**. Enregistrez rapidement les résultats générés.
</Note>

## Response

<ResponseField name="code" type="integer">
  Code de statut de la réponse
</ResponseField>

<ResponseField name="data" type="array">
  Tableau de données de la réponse

  <Expandable title="Propriétés">
    <ResponseField name="status" type="string">
      Statut de la tâche

      * `submitted` — Soumise
    </ResponseField>

    <ResponseField name="task_id" type="string">
      Identifiant unique de la tâche
    </ResponseField>
  </Expandable>
</ResponseField>