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

# FLUX.2 Pro Image Generation

> - Asynchronous processing mode, returns a task ID for subsequent query
- Supports text-to-image and image-to-image; automatically switches to image-to-image when image_url is provided
- Supports up to 8 reference images for consistency in subject, product, style, and composition
- Supports 7 common image aspect ratios
- Supports 1K / 2K resolution levels
- Submitted prompts undergo platform sensitive word / safety review; 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.

  Get the API Key:

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

  Add the following in the request header:

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

## Body

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

  Fixed value: `"flux_2_pro"`
</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, up to 5000 characters.

      * Supports Chinese and English; it is recommended to clearly describe the subject, scene, composition, lighting, material, and reference image features to be retained
      * When performing image-to-image, the prompt should clearly specify content to be retained and modified
      * Submissions will undergo platform sensitivity/safety review; hitting violation content will directly return an error
    </ParamField>

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

      * Up to 8 reference images
      * Maximum 10 MB per image
      * Supports jpeg, png, webp
      * Supports the following two formats:
        1. Publicly accessible URLs
        2. Complete Base64 Data URIs, e.g., `data:image/jpeg;base64,/9j/4AAQ...`

      <Warning>
        URLs must be publicly accessible without requiring login, cookies, or temporary page authorization.
      </Warning>
    </ParamField>

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

      Supported values:

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

      <Warning>
        `aspect_ratio` represents the target ratio step of the model and does not guarantee fixed pixel dimensions. Different generation modes may return native model sizes close to the ratio. For example, tested 1K image-to-image 16:9 returns 1344×768, 2K text-to-image 16:9 returns 1920×1088.
      </Warning>
    </ParamField>

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

      * `1K` - Basic resolution (default), approximately consumes 5 points per image
      * `2K` - High resolution, approximately consumes 7 points per image
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="out_task_id" type="string" required>
  Caller-defined task ID used for idempotent submission and querying results.

  * Length is 1-64 characters
  * Only letters, numbers, underscores, and hyphens are allowed
  * Cannot be reused under the same API Key
</ParamField>

## Billing

| resolution | Estimated Credits Used | Number of Generations |
| - | -: | -: |
| `1K` | 5 | 1 image |
| `2K` | 7 | 1 image |

When the submission is successful, the `estimated_credits` in the response is the estimated credits used. After the task is completed, the actual credits used can be checked in the `credits_used` field of the query interface response. If the task generation fails, the system will automatically refund the pre-deducted credits for this task.

## Response

<ResponseField name="out_task_id" type="string">
  Caller 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, in ISO 8601 format.
</ResponseField>

## Query Results

After the submission succeeds, call the endpoint with 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": "flux_2_pro_task_001"
  }'
```

Task statuses include `pending`, `processing`, `completed`, and `failed`. After the task is completed, the result images are located in `data.output`, and the actual credits used are located in `data.credits_used`.

<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": "flux_2_pro",
      "params": {
        "prompt": "A futuristic electric sports car parked in front of a modern glass building, blue hour, wet ground reflecting the building lights, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
        "aspect_ratio": "16:9",
        "resolution": "2K"
      },
      "out_task_id": "flux_2_pro_task_001"
    }'
  ```

  ```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": "flux_2_pro",
      "params": {
        "prompt": "Transform the reference product image into a premium nighttime advertising style while preserving the bottle shape, proportions, spray nozzle, transparent glass structure, and label text. Use a dark gray background and cool rim lighting, and keep only one product.",
        "image_url": [
          "https://example.com/product-reference.png"
        ],
        "aspect_ratio": "16:9",
        "resolution": "1K"
      },
      "out_task_id": "flux_2_pro_image_task_001"
    }'
  ```

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

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

  payload = {
      "model": "flux_2_pro",
      "params": {
          "prompt": "Cinematic product advertising photography, a glass perfume bottle placed on a black stone pedestal, realistic reflections and natural shadows",
          "aspect_ratio": "16:9",
          "resolution": "1K"
      },
      "out_task_id": "flux_2_pro_python_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 response = await fetch("https://aireiter.com/api/openapi/submit", {
    method: "POST",
    headers: {
      Authorization: "Bearer <token>",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      model: "flux_2_pro",
      params: {
        prompt: "Cinematic product advertising photography, a glass perfume bottle placed on a black stone pedestal, realistic reflections and natural shadows",
        aspect_ratio: "16:9",
        resolution: "1K"
      },
      out_task_id: "flux_2_pro_javascript_001"
    })
  });

  console.log(await response.json());
  ```

  ```go Go theme={null}
  package main

  import (
      "bytes"
      "fmt"
      "io"
      "net/http"
  )

  func main() {
      payload := []byte(`{
        "model":"flux_2_pro",
        "params":{
          "prompt":"Cinematic product advertising photography, a glass perfume bottle placed on a black stone pedestal, realistic reflections and natural shadows",
          "aspect_ratio":"16:9",
          "resolution":"1K"
        },
        "out_task_id":"flux_2_pro_go_001"
      }`)

      req, _ := http.NewRequest(
          http.MethodPost,
          "https://aireiter.com/api/openapi/submit",
          bytes.NewBuffer(payload),
      )
      req.Header.Set("Authorization", "Bearer <token>")
      req.Header.Set("Content-Type", "application/json")

      response, err := http.DefaultClient.Do(req)
      if err != nil {
          panic(err)
      }
      defer response.Body.Close()

      body, _ := io.ReadAll(response.Body)
      fmt.Println(string(body))
  }
  ```

  ```java Java theme={null}
  import java.net.URI;
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;

  public class Main {
      public static void main(String[] args) throws Exception {
          String payload = """
          {
            "model": "flux_2_pro",
            "params": {
              "prompt": "Cinematic product advertising photography, a glass perfume bottle placed on a black stone pedestal, realistic reflections and natural shadows",
              "aspect_ratio": "16:9",
              "resolution": "1K"
            },
            "out_task_id": "flux_2_pro_java_001"
          }
          """;

          HttpRequest request = HttpRequest.newBuilder()
              .uri(URI.create("https://aireiter.com/api/openapi/submit"))
              .header("Authorization", "Bearer <token>")
              .header("Content-Type", "application/json")
              .POST(HttpRequest.BodyPublishers.ofString(payload))
              .build();

          HttpResponse<String> response = HttpClient.newHttpClient().send(
              request,
              HttpResponse.BodyHandlers.ofString()
          );
          System.out.println(response.body());
      }
  }
  ```

  ```php PHP theme={null}
  <?php

  $payload = [
      "model" => "flux_2_pro",
      "params" => [
          "prompt" => "Cinematic product advertising photography, a glass perfume bottle placed on a black stone pedestal, realistic reflections and natural shadows",
          "aspect_ratio" => "16:9",
          "resolution" => "1K"
      ],
      "out_task_id" => "flux_2_pro_php_001"
  ];

  $ch = curl_init("https://aireiter.com/api/openapi/submit");
  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"
  ]);

  echo curl_exec($ch);
  curl_close($ch);
  ?>
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'json'
  require 'uri'

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

  payload = {
    model: "flux_2_pro",
    params: {
      prompt: "A futuristic electric sports car parked in front of a modern glass building, blue hour, wet ground reflecting the building lights, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
      aspect_ratio: "16:9",
      resolution: "2K"
    },
    out_task_id: "flux_2_pro_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": "flux_2_pro",
      "params": [
          "prompt": "A futuristic electric sports car parked in front of a modern glass building, blue hour, wet ground reflecting the building lights, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
          "aspect_ratio": "16:9",
          "resolution": "2K"
      ],
      "out_task_id": "flux_2_pro_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"": ""flux_2_pro"",
                    ""params"": {
                        ""prompt"": ""A futuristic electric sports car parked in front of a modern glass building, blue hour, wet ground reflecting the building lights, commercial automotive photography, realistic materials and natural shadows, no text, no watermark"",
                        ""aspect_ratio"": ""16:9"",
                        ""resolution"": ""2K""
                    },
                    ""out_task_id"": ""flux_2_pro_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\":\"flux_2_pro\",\"params\":{\"prompt\":\"A futuristic electric sports car parked in front of a modern glass building, blue hour, wet ground reflecting the building lights, commercial automotive photography, realistic materials and natural shadows, no text, no watermark\",\"aspect_ratio\":\"16:9\",\"resolution\":\"2K\"},\"out_task_id\":\"flux_2_pro_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": @"flux_2_pro",
              @"params": @{
                  @"prompt": @"A futuristic electric sports car parked in front of a modern glass building, blue hour, wet ground reflecting the building lights, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
                  @"aspect_ratio": @"16:9",
                  @"resolution": @"2K"
              },
              @"out_task_id": @"flux_2_pro_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": "flux_2_pro",
    "params": {
      "prompt": "A futuristic electric sports car parked in front of a modern glass building, blue hour, wet ground reflecting the building lights, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
      "aspect_ratio": "16:9",
      "resolution": "2K"
    },
    "out_task_id": "flux_2_pro_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": "flux_2_pro",
          "params": {
              "prompt": "A futuristic electric sports car parked in front of a modern glass building, blue hour, wet ground reflecting the building lights, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
              "aspect_ratio": "16:9",
              "resolution": "2K"
          },
          "out_task_id": "flux_2_pro_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 = "flux_2_pro",
    params = list(
      prompt = "A futuristic electric sports car parked in front of a modern glass building, blue hour, wet ground reflecting the building lights, commercial automotive photography, realistic materials and natural shadows, no text, no watermark",
      aspect_ratio = "16:9",
      resolution = "2K"
    ),
    out_task_id = "flux_2_pro_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": {
      "task_id": "",
      "status": "pending",
      "created_at": "2026-07-22T10:37:44.800Z",
      "out_task_id": "flux_2_pro_task_001",
      "estimated_credits": 5
    },
    "ok": true
  }
  ```

  ```json 400 theme={null}
  {
    "statusCode": 400,
    "message": "Invalid aspect_ratio: \"widescreen\". Allowed: [1:1, 4:3, 3:4, 16:9, 9:16, 3:2, 2:3]",
    "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.