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

# Qwen Image 3.0 Image Generation and Editing

> - Asynchronous processing mode, returns a task ID for subsequent queries
- Supports text-to-image and image-to-image. If no reference image is provided, it uses text-to-image
- Supports up to 3 reference images and generating 1-6 images at a time
- Supports 1K / 2K resolutions and 7 common image aspect ratios
- Submitted prompts undergo platform sensitive word / security review, and violating content will be directly rejected


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

## Authorizations

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

  Visit the <a href={apiKeyUrl} target="_blank">API Key management page</a> to get your API Key, and add the following to the request header:

  ```text theme={null}
  Authorization: Bearer YOUR_API_KEY
  ```
</ParamField>

## Body

<ParamField body="model" type="string" required>
  Model name, fixed value: `"qwen_image_3"`.
</ParamField>

<ParamField body="params" type="object" required>
  Model parameter object.

  <Expandable title="params Object Properties">
    <ParamField body="prompt" type="string" required>
      Image generation or editing instruction. Chinese and English are supported.

      It is recommended to clearly describe the subject, scene, composition, lighting, materials, text content, and the parts in the reference image that need to be preserved or modified.
    </ParamField>

    <ParamField body="image_url" type="string[]">
      Array of reference images. If provided, image-to-image mode is used; if omitted, text-to-image mode is used.

      * Up to 3 reference images
      * Maximum size per image: 10MB
      * Supports jpeg, png, and webp
      * Supports publicly accessible URLs or a complete Base64 Data URI

      <Warning>
        The image URL must be directly accessible from the public internet and cannot rely on login status, cookies, or temporary page authorization.
      </Warning>
    </ParamField>

    <ParamField body="resolution" type="string" default="1K">
      Output resolution tier.

      * `1K` - Standard resolution (default)
      * `2K` - High-definition resolution
    </ParamField>

    <ParamField body="aspect_ratio" type="string" default="1:1">
      Output image aspect ratio.

      Supported values:

      * `1:1` - Square (default)
      * `3:2` / `2:3` - Classic landscape / portrait
      * `4:3` / `3:4` - Standard landscape / portrait
      * `16:9` / `9:16` - Widescreen landscape / portrait
    </ParamField>

    <ParamField body="output_n" type="integer" default="1">
      Number of images generated in this task, ranging from `1` to `6`.
    </ParamField>

    <ParamField body="prompt_extend" type="boolean" default="false">
      Intelligent prompt rewriting. Disabled by default to keep results predictable. Set to `true` when intelligent rewriting is needed.
    </ParamField>

    <ParamField body="prompt_extend_mode" type="string" default="direct">
      Prompt rewriting mode. Takes effect only when `prompt_extend` is `true`.

      * `direct` - Balanced rewriting, supports both text-to-image and image-to-image
      * `agent` - Aggressive rewriting, supports text-to-image only
    </ParamField>

    <ParamField body="negative_prompt" type="string">
      Negative prompt, used to describe content that you do not want to appear in the result, such as blur, distortion, or incorrect text.
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="out_task_id" type="string" required>
  Client-defined task ID, used for idempotent submission and result queries.

  * Length: 1-64 characters
  * It is recommended to use only letters, numbers, underscores, and hyphens
  * Do not reuse it under the same API Key
</ParamField>

## Response

<ResponseField name="out_task_id" type="string">
  Caller task ID, can be used to query the task Status and result.
</ResponseField>

<ResponseField name="status" type="string">
  Initial status, usually `"pending"`.
</ResponseField>

<ResponseField name="created_at" type="string">
  Task creation time, in ISO 8601 format.
</ResponseField>

## Query Results

After submission succeeds, call the query endpoint using the same `out_task_id`:

```bash theme={null}
curl --request POST \
  --url https://aireiter.com/api/openapi/query \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
    "out_task_id": "qwen_image_3_task_001"
  }'
```

Task statuses include `pending`, `processing`, `completed`, and `failed`. After the task is completed, the image array is located in `data.output`.

<RequestExample>
  ```bash cURL（Text-to-Image） theme={null}
  curl --request POST \
    --url https://aireiter.com/api/openapi/submit \
    --header 'Authorization: Bearer <token>' \
    --header 'Content-Type: application/json' \
    --data '{
      "model": "qwen_image_3",
      "params": {
        "prompt": "A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
        "resolution": "2K",
        "aspect_ratio": "16:9",
        "output_n": 1,
        "prompt_extend": true,
        "prompt_extend_mode": "agent"
      },
      "out_task_id": "qwen_image_3_task_001"
    }'
  ```

  ```bash cURL（Image-to-Image） theme={null}
  curl --request POST \
    --url https://aireiter.com/api/openapi/submit \
    --header 'Authorization: Bearer <token>' \
    --header 'Content-Type: application/json' \
    --data '{
      "model": "qwen_image_3",
      "params": {
        "prompt": "Keep the product subject and label structure, change the background to a dark gray premium advertising studio, and add cool rim lighting",
        "image_url": ["https://example.com/product-reference.png"],
        "resolution": "1K",
        "aspect_ratio": "1:1",
        "output_n": 1
      },
      "out_task_id": "qwen_image_3_edit_001"
    }'
  ```

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

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

  payload = {
      "model": "qwen_image_3",
      "params": {
          "prompt": "A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
          "resolution": "2K",
          "aspect_ratio": "16:9",
          "output_n": 1,
          "prompt_extend": True,
          "prompt_extend_mode": "agent"
      },
      "out_task_id": "qwen_image_3_task_001"
  }

  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: "qwen_image_3",
    params: {
      prompt: "A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
      resolution: "2K",
      aspect_ratio: "16:9",
      output_n: 1,
      prompt_extend: true,
      prompt_extend_mode: "agent"
    },
    out_task_id: "qwen_image_3_task_001"
  };

  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": "qwen_image_3",
          "params": map[string]interface{}{
              "prompt": "A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
              "resolution": "2K",
              "aspect_ratio": "16:9",
              "output_n": 1,
              "prompt_extend": true,
              "prompt_extend_mode": "agent",
          },
          "out_task_id": "qwen_image_3_task_001",
      }

      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": "qwen_image_3",
                "params": {
                  "prompt": "A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
                  "resolution": "2K",
                  "aspect_ratio": "16:9",
                  "output_n": 1,
                  "prompt_extend": true,
                  "prompt_extend_mode": "agent"
                },
                "out_task_id": "qwen_image_3_task_001"
              }
          """;

          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" => "qwen_image_3",
      "params" => [
          "prompt" => "A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
          "resolution" => "2K",
          "aspect_ratio" => "16:9",
          "output_n" => 1,
          "prompt_extend" => true,
          "prompt_extend_mode" => "agent"
      ],
      "out_task_id" => "qwen_image_3_task_001"
  ];

  $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: "qwen_image_3",
    params: {
      prompt: "A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
      resolution: "2K",
      aspect_ratio: "16:9",
      output_n: 1,
      prompt_extend: true,
      prompt_extend_mode: "agent"
    },
    out_task_id: "qwen_image_3_task_001"
  }

  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": "qwen_image_3",
      "params": [
          "prompt": "A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
          "resolution": "2K",
          "aspect_ratio": "16:9",
          "output_n": 1,
          "prompt_extend": true,
          "prompt_extend_mode": "agent"
      ],
      "out_task_id": "qwen_image_3_task_001"
  ]

  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"": ""qwen_image_3"",
                    ""params"": {
                        ""prompt"": ""A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark"",
                        ""resolution"": ""2K"",
                        ""aspect_ratio"": ""16:9"",
                        ""output_n"": 1,
                        ""prompt_extend"": true,
                        ""prompt_extend_mode"": ""agent""
                    },
                    ""out_task_id"": ""qwen_image_3_task_001""
                }";

          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\":\"qwen_image_3\",\"params\":{\"prompt\":\"A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark\",\"resolution\":\"2K\",\"aspect_ratio\":\"16:9\",\"output_n\":1,\"prompt_extend\":true,\"prompt_extend_mode\":\"agent\"},\"out_task_id\":\"qwen_image_3_task_001\"}";

          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": @"qwen_image_3",
              @"params": @{
                  @"prompt": @"A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
                  @"resolution": @"2K",
                  @"aspect_ratio": @"16:9",
                  @"output_n": @1,
                  @"prompt_extend": @YES,
                  @"prompt_extend_mode": @"agent"
              },
              @"out_task_id": @"qwen_image_3_task_001"
          };

          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": "qwen_image_3",
    "params": {
      "prompt": "A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
      "resolution": "2K",
      "aspect_ratio": "16:9",
      "output_n": 1,
      "prompt_extend": true,
      "prompt_extend_mode": "agent"
    },
    "out_task_id": "qwen_image_3_task_001"
  }|}

  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": "qwen_image_3",
          "params": {
              "prompt": "A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
              "resolution": "2K",
              "aspect_ratio": "16:9",
              "output_n": 1,
              "prompt_extend": true,
              "prompt_extend_mode": "agent"
          },
          "out_task_id": "qwen_image_3_task_001"
      };

    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 = "qwen_image_3",
    params = list(
      prompt = "A futuristic electric sports car in front of a modern glass building, blue hour, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
      resolution = "2K",
      aspect_ratio = "16:9",
      output_n = 1,
      prompt_extend = TRUE,
      prompt_extend_mode = "agent"
    ),
    out_task_id = "qwen_image_3_task_001"
  )

  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": "qwen_image_3_task_001",
        "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 top up and try again"
      }
    }
  ```

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


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