> ## 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 3 Video Video Generation

> - Black Forest Labs multimodal video generation model
- Supports text-to-video, ordered keyframes, and video continuation
- Supports 5-20 seconds, HD/FHD output, and native audio
- Asynchronous processing mode, returns a task ID for subsequent queries


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

<Note>
  The model name for FLUX 3 Video in AIReiter is `flux_3_video`. It currently supports three modes: text-to-video, ordered keyframes, and video continuation.
</Note>

## Authorizations

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

  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:

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

## Body

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

  * `flux_3_video`
</ParamField>

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

  <Expandable title="Properties of the params Object">
    <ParamField body="mode" type="string" default="t2v">
      Generation mode:

      * `t2v` - text-to-video, generate video using only a prompt
      * `i2v` - ordered keyframes, use 1-10 images to control video content and transitions
      * `v2v` - video continuation, continue generating dynamic content from a source video
    </ParamField>

    <ParamField body="prompt" type="string" required>
      Text description for video generation.

      It is recommended to describe the subject, scene, action, camera movement, visual style, dialogue, and ambient sound.
    </ParamField>

    <ParamField body="image_url" type="string | string[]">
      Ordered keyframe image URLs, used only in `i2v` mode.

      * Supports 1-10 publicly accessible images
      * The image order is the playback order
      * The first and last images can be used to define the start and end frames of the video

      <Warning>`i2v` mode must provide at least one image; do not pass this parameter in other modes.</Warning>
    </ParamField>

    <ParamField body="video_url" type="string | string[]">
      Source video URL, used only in `v2v` mode.

      Currently, only one publicly accessible MP4 video is supported at most. When passed as an array, only the first URL is used.

      <Warning>`v2v` mode must provide a source video; do not pass this parameter in other modes.</Warning>
    </ParamField>

    <ParamField body="video_length" type="integer" default="5">
      Output video duration, in seconds.

      Supports integers from `5` to `20`.
    </ParamField>

    <ParamField body="resolution" type="string" default="hd">
      Output quality:

      * `hd` - HD
      * `fhd` - FHD

      <Note>FHD has more pixels than HD, and the exact output size varies by aspect ratio.</Note>
    </ParamField>

    <ParamField body="aspect_ratio" type="string" default="auto">
      Video aspect ratio:

      * `auto` - Automatic
      * `21:9` - Ultrawide
      * `2:1` - Wide screen
      * `16:9` - Landscape
      * `4:3` - Standard landscape
      * `1:1` - Square
      * `3:4` - Standard portrait
      * `9:16` - Portrait
    </ParamField>

    <ParamField body="generate_audio" type="boolean" default="true">
      Whether to generate native audio synchronized with the video.

      Can include dialogue, ambient sound, and sound effects.
    </ParamField>

    <ParamField body="safety_tolerance" type="integer" default="2">
      Content safety tolerance, supports integers from `0` to `4`.

      * `0` - Strictest filtering
      * `4` - Most permissive setting
    </ParamField>
  </Expandable>
</ParamField>

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

  Generated by the caller and guaranteed to be unique. Use this ID later to query the task status and results.
</ParamField>

## Response

<ResponseField name="out_task_id" type="string">
  The initiator's task ID, which can be used to query the result.
</ResponseField>

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

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

## Query Task

FLUX 3 Video uses asynchronous processing. After submission succeeds, use the same `out_task_id` to query the task:

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

After the task is completed, the `output` array in the Response will contain the generated video URL. For complete fields, see [Get Task Status](/en/api-reference/tasks/status).

## Request Examples

<RequestExample>
  ```bash cURL (Text-to-Video) theme={null}
  curl --request POST \
    --url https://aireiter.com/api/openapi/submit \
    --header 'Authorization: Bearer <token>' \
    --header 'Content-Type: application/json' \
    --data '{
      "model": "flux_3_video",
      "params": {
        "mode": "t2v",
        "prompt": "Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps",
        "video_length": 5,
        "resolution": "hd",
        "aspect_ratio": "16:9",
        "generate_audio": true,
        "safety_tolerance": 2
      },
      "out_task_id": "flux_3_video_t2v_123456"
    }'
  ```

  ```bash cURL (Ordered Keyframes) theme={null}
  curl --request POST \
    --url https://aireiter.com/api/openapi/submit \
    --header 'Authorization: Bearer <token>' \
    --header 'Content-Type: application/json' \
    --data '{
      "model": "flux_3_video",
      "params": {
        "mode": "i2v",
        "prompt": "Generate natural, coherent motion and camera movement between two keyframes while keeping the subject appearance consistent",
        "image_url": [
          "https://example.com/first-frame.jpg",
          "https://example.com/last-frame.jpg"
        ],
        "video_length": 5,
        "resolution": "fhd",
        "aspect_ratio": "1:1",
        "generate_audio": true,
        "safety_tolerance": 2
      },
      "out_task_id": "flux_3_video_i2v_123456"
    }'
  ```

  ```bash cURL (Video Continuation) theme={null}
  curl --request POST \
    --url https://aireiter.com/api/openapi/submit \
    --header 'Authorization: Bearer <token>' \
    --header 'Content-Type: application/json' \
    --data '{
      "model": "flux_3_video",
      "params": {
        "mode": "v2v",
        "prompt": "Continue the source video’s movement direction, composition, and lighting so the shot naturally transitions into the next forest scene",
        "video_url": "https://example.com/source-video.mp4",
        "video_length": 5,
        "resolution": "hd",
        "aspect_ratio": "auto",
        "generate_audio": true,
        "safety_tolerance": 2
      },
      "out_task_id": "flux_3_video_v2v_123456"
    }'
  ```

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

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

  payload = {
      "model": "flux_3_video",
      "params": {
          "mode": "t2v",
          "prompt": "Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps",
          "video_length": 5,
          "resolution": "hd",
          "aspect_ratio": "16:9",
          "generate_audio": True,
          "safety_tolerance": 2
      },
      "out_task_id": "flux_3_video_t2v_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: "flux_3_video",
    params: {
      mode: "t2v",
      prompt: "Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps",
      video_length: 5,
      resolution: "hd",
      aspect_ratio: "16:9",
      generate_audio: true,
      safety_tolerance: 2
    },
    out_task_id: "flux_3_video_t2v_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": "flux_3_video",
          "params": map[string]interface{}{
              "mode": "t2v",
              "prompt": "Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps",
              "video_length": 5,
              "resolution": "hd",
              "aspect_ratio": "16:9",
              "generate_audio": true,
              "safety_tolerance": 2,
          },
          "out_task_id": "flux_3_video_t2v_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": "flux_3_video",
                "params": {
                  "mode": "t2v",
                  "prompt": "Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps",
                  "video_length": 5,
                  "resolution": "hd",
                  "aspect_ratio": "16:9",
                  "generate_audio": true,
                  "safety_tolerance": 2
                },
                "out_task_id": "flux_3_video_t2v_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" => "flux_3_video",
      "params" => [
          "mode" => "t2v",
          "prompt" => "Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps",
          "video_length" => 5,
          "resolution" => "hd",
          "aspect_ratio" => "16:9",
          "generate_audio" => true,
          "safety_tolerance" => 2
      ],
      "out_task_id" => "flux_3_video_t2v_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: "flux_3_video",
    params: {
      mode: "t2v",
      prompt: "Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps",
      video_length: 5,
      resolution: "hd",
      aspect_ratio: "16:9",
      generate_audio: true,
      safety_tolerance: 2
    },
    out_task_id: "flux_3_video_t2v_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": "flux_3_video",
      "params": [
          "mode": "t2v",
          "prompt": "Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps",
          "video_length": 5,
          "resolution": "hd",
          "aspect_ratio": "16:9",
          "generate_audio": true,
          "safety_tolerance": 2
      ],
      "out_task_id": "flux_3_video_t2v_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"": ""flux_3_video"",
                    ""params"": {
                        ""mode"": ""t2v"",
                        ""prompt"": ""Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps"",
                        ""video_length"": 5,
                        ""resolution"": ""hd"",
                        ""aspect_ratio"": ""16:9"",
                        ""generate_audio"": true,
                        ""safety_tolerance"": 2
                    },
                    ""out_task_id"": ""flux_3_video_t2v_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\":\"flux_3_video\",\"params\":{\"mode\":\"t2v\",\"prompt\":\"Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps\",\"video_length\":5,\"resolution\":\"hd\",\"aspect_ratio\":\"16:9\",\"generate_audio\":true,\"safety_tolerance\":2},\"out_task_id\":\"flux_3_video_t2v_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": @"flux_3_video",
              @"params": @{
                  @"mode": @"t2v",
                  @"prompt": @"Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps",
                  @"video_length": @5,
                  @"resolution": @"hd",
                  @"aspect_ratio": @"16:9",
                  @"generate_audio": @YES,
                  @"safety_tolerance": @2
              },
              @"out_task_id": @"flux_3_video_t2v_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": "flux_3_video",
    "params": {
      "mode": "t2v",
      "prompt": "Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps",
      "video_length": 5,
      "resolution": "hd",
      "aspect_ratio": "16:9",
      "generate_audio": true,
      "safety_tolerance": 2
    },
    "out_task_id": "flux_3_video_t2v_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": "flux_3_video",
          "params": {
              "mode": "t2v",
              "prompt": "Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps",
              "video_length": 5,
              "resolution": "hd",
              "aspect_ratio": "16:9",
              "generate_audio": true,
              "safety_tolerance": 2
          },
          "out_task_id": "flux_3_video_t2v_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 = "flux_3_video",
    params = list(
      mode = "t2v",
      prompt = "Cinematic tracking shot: a red fox walks through a misty forest, accompanied by natural ambient sounds and soft footsteps",
      video_length = 5,
      resolution = "hd",
      aspect_ratio = "16:9",
      generate_audio = TRUE,
      safety_tolerance = 2
    ),
    out_task_id = "flux_3_video_t2v_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": "flux_3_video_t2v_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 top up and try again"
      }
    }
  ```

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

## Mode Rules

| mode | Required Assets | Asset Limitations |
| - | - | - |
| `t2v` | None | Do not pass `image_url` or `video_url` |
| `i2v` | `image_url` | 1-10 ordered images |
| `v2v` | `video_url` | At most one source video |

<Warning>
  Please ensure that the image and video URLs are directly accessible from the public internet. The task is processed asynchronously, so do not keep the HTTP connection from the submission request open while waiting for the final video.
</Warning>