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

# Seedream V5 lite Image Generation

> - Asynchronous processing mode, returns a task ID for subsequent queries
- Higher quality image generation
- Supports online search to enhance generation effects


export const apiKeyUrl = 'https://aireiter.com/keys';

## Authorizations

<ParamField header="Authorization" type="string" required>
  All endpoints require Bearer Token authentication

  Get the API Key:

  Visit the <a href={apiKeyUrl} target="_blank">API Key management page</a> to get your API Key

  Add the following to the request headers:

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

## Body

<ParamField body="model" type="string" required>
  Model name

  Fixed value: `"seedream_v5_lite"`
</ParamField>

<ParamField body="params" type="object" required>
  Model parameters object

  <Expandable title="params object properties">
    <ParamField body="prompt" type="string" required>
      Text description for image generation

      No limitation
    </ParamField>

    <ParamField body="image_url" type="string[]">
      List of reference image URLs for image-to-image generation

      * Maximum 9 images
      * Supports the following two formats:
        1. Publicly accessible URLs
        2. Base64 encoded format
           * Must use the full Data URI format: `data:image/{format};base64,{base64 data}`
           * Supported image formats: jpeg, png, webp
           * Example: `data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABg...`
           * ⚠️ Note: The prefix `data:image/jpeg;base64,` must be included, base64 image size must not exceed 10MB
    </ParamField>

    <ParamField body="aspect_ratio" type="string">
      Aspect ratio for image generation

      Supported aspect ratios:

      * `1:1` - Square
      * `3:2` - Landscape 3:2
      * `2:3` - Portrait 2:3
      * `4:3` - Landscape 4:3
      * `3:4` - Portrait 3:4
      * `16:9` - Landscape widescreen
      * `9:16` - Portrait vertical
      * `21:9` - Ultra widescreen
    </ParamField>

    <ParamField body="resolution" type="string" default="2K">
      Image resolution

      Supported resolutions:

      * `2K` - 2K resolution (default)
      * `3K` - 3K high definition resolution
    </ParamField>

    <ParamField body="web_search" type="boolean" default="false">
      Web search toggle

      When enabled, the model autonomously decides based on the prompt whether to search internet content (such as products, weather, etc.) to enhance generation quality, but this increases latency
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="callback_url" type="string">
  Callback URL upon task completion
</ParamField>

<ParamField body="metadata" type="object">
  Custom metadata, returned as-is
</ParamField>

<ParamField body="out_task_id" type="string" required>
  Initiator task ID

  User-defined task identifier, required
</ParamField>

## Response

<ResponseField name="out_task_id" type="string">
  Initiator task ID, which can be used to query the result
</ResponseField>

<ResponseField name="status" type="string">
  Initial status, fixed as `"pending"`
</ResponseField>

<ResponseField name="estimated_credits" type="number">
  Estimated credit consumption
</ResponseField>

<ResponseField name="created_at" type="string">
  Creation time (ISO format)
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl --request POST \
    --url https://aireiter.com/api/openapi/submit \
    --header 'Authorization: Bearer <token>' \
    --header 'Content-Type: application/json' \
    --data '{
      "model": "seedream_v5_lite",
      "params": {
        "prompt": "An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style",
        "aspect_ratio": "16:9",
        "resolution": "3K",
        "web_search": false
      },
      "out_task_id": "my_task_123456"
    }'
  ```

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

  url = "https://aireiter.com/api/openapi/submit"

  payload = {
      "model": "seedream_v5_lite",
      "params": {
          "prompt": "An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style",
          "aspect_ratio": "16:9",
          "resolution": "3K",
          "web_search": False
      },
      "out_task_id": "my_task_123456"
  }

  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://aireiter.com/api/openapi/submit";

  const payload = {
    model: "seedream_v5_lite",
    params: {
      prompt: "An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style",
      aspect_ratio: "16:9",
      resolution: "3K",
      web_search: false
    },
    out_task_id: "my_task_123456"
  };

  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://aireiter.com/api/openapi/submit"

      payload := map[string]interface{}{
          "model": "seedream_v5_lite",
          "params": map[string]interface{}{
              "prompt":        "An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style",
              "aspect_ratio":  "16:9",
              "resolution":    "3K",
              "web_search":    false,
          },
          "out_task_id": "my_task_123456",
      }

      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://aireiter.com/api/openapi/submit";

          String payload = """
          {
            "model": "seedream_v5_lite",
            "params": {
              "prompt": "An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style",
              "aspect_ratio": "16:9",
              "resolution": "3K",
              "web_search": false
            },
            "out_task_id": "my_task_123456"
          }
          """;

          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://aireiter.com/api/openapi/submit";

  $payload = [
      "model" => "seedream_v5_lite",
      "params" => [
          "prompt" => "An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style",
          "aspect_ratio" => "16:9",
          "resolution" => "3K",
          "web_search" => false
      ],
      "out_task_id" => "my_task_123456"
  ];

  $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://aireiter.com/api/openapi/submit")

  payload = {
    model: "seedream_v5_lite",
    params: {
      prompt: "An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style",
      aspect_ratio: "16:9",
      resolution: "3K",
      web_search: false
    },
    out_task_id: "my_task_123456"
  }

  http = Net::HTTP.new(url.host, url.port)

  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://aireiter.com/api/openapi/submit")!

  let payload: [String: Any] = [
      "model": "seedream_v5_lite",
      "params": [
          "prompt": "An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style",
          "aspect_ratio": "16:9",
          "resolution": "3K",
          "web_search": false
      ] as [String: Any],
      "out_task_id": "my_task_123456"
  ]

  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://aireiter.com/api/openapi/submit";

          var payload = @"{
              ""model"": ""seedream_v5_lite"",
              ""params"": {
                  ""prompt"": ""An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style"",
                  ""aspect_ratio"": ""16:9"",
                  ""resolution"": ""3K"",
                  ""web_search"": false
              },
              ""out_task_id"": ""my_task_123456""
          }";

          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://aireiter.com/api/openapi/submit";
          const char *payload = "{"
              "\"model\":\"seedream_v5_lite\","
              "\"params\":{"
                  "\"prompt\":\"An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style\","
                  "\"aspect_ratio\":\"16:9\","
                  "\"resolution\":\"3K\","
                  "\"web_search\":false"
              "},"
              "\"out_task_id\":\"my_task_123456\""
          "}";

          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://aireiter.com/api/openapi/submit"];

          NSDictionary *payload = @{
              @"model": @"seedream_v5_lite",
              @"params": @{
                  @"prompt": @"An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style",
                  @"aspect_ratio": @"16:9",
                  @"resolution": @"3K",
                  @"web_search": @NO
              },
              @"out_task_id": @"my_task_123456"
          };

          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://aireiter.com/api/openapi/submit"

  let payload = {|{
    "model": "seedream_v5_lite",
    "params": {
      "prompt": "An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style",
      "aspect_ratio": "16:9",
      "resolution": "3K",
      "web_search": false
    },
    "out_task_id": "my_task_123456"
  }|}

  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://aireiter.com/api/openapi/submit');

    final payload = {
      'model': 'seedream_v5_lite',
      'params': {
        'prompt': 'An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style',
        'aspect_ratio': '16:9',
        'resolution': '3K',
        'web_search': false
      },
      'out_task_id': 'my_task_123456'
    };

    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://aireiter.com/api/openapi/submit"

  payload <- list(
    model = "seedream_v5_lite",
    params = list(
      prompt = "An orange tabby cat sitting on the windowsill, with Tokyo night view outside, cyberpunk style",
      aspect_ratio = "16:9",
      resolution = "3K",
      web_search = FALSE
    ),
    out_task_id = "my_task_123456"
  )

  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}
  {
    "statusCode": 200,
    "message": "",
    "data": {
        "out_task_id": "my_task_123456",
        "status": "pending",
        "estimated_credits": 100,
        "created_at": "2025-12-22T06:03:28.242Z"
    }
  }
  ```

  ```json 400 theme={null}
    {
        "statusCode": 400,
        "message": "Invalid request parameters",
        "ok": false
    }
  ```

  ```json 401 theme={null}
  {
    "error": {
      "code": 401,
      "message": "Authentication failed, please check your API key"
    }
  }
  ```

  ```json 433 theme={null}
    {
      "error": {
        "code": 433,
        "message": "Insufficient account balance, please recharge and try again"
      }
    }
  ```

  ```json 500 theme={null}
  {
    "error": {
      "code": 500,
      "message": "Internal server error, please try again later"
    }
  }
  ```
</ResponseExample>