Name: FLUX 3 API: Video with Audio by Black Forest Labs
Brand: magicapi
SKU: api-magicapi-generate-video-with-audio-from-text-images-video-black-forest-labs-flux-3
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Video with Audio Generator API (FLUX 3)

## Overview
FLUX 3 is a multimodal model from Black Forest Labs that generates video with synchronized audio from text, images or video. It is offered as an early access preview. You write a prompt describing the scene, action, camera moves and any audio you want, and the model returns an MP4 clip of 5 to 20 seconds at 720p or 1080p. You can also start or storyboard the clip with images, or continue an existing video from its final frames.

## Features
- **Text to video with audio:** the clip comes with synchronized audio (ambient sound, speech, effects). Set `generate_audio` to false for a silent clip.
- **Image to video and storyboards:** one image in `images` opens the clip, two images start and end it, and three or more (up to 10) become a storyboard (needs an explicit `duration`). PNG, JPEG or WebP.
- **Video continuation:** `start_video` continues a video from its final frames, to extend a shot or chain generations into a longer sequence. MP4, at most 50MB and 15 seconds. It can't be combined with `images`.
- **Duration:** `auto` (the default, the model picks a length to fit the content) or 5 to 20 seconds.
- **Resolution:** `720p` (the default) or `1080p`.
- **Aspect ratio:** `auto` (picked from your prompt and inputs) or 21:9, 2:1, 16:9, 4:3, 1:1, 3:4, 9:16.
- **Draft mode:** `draft` generates a fast, low-cost 720p preview instead of a full-quality clip.
- **Prompt expansion:** the prompt is interpreted and expanded before generation, so plain language works.
- **Safety tolerance:** `safety_tolerance` from 0 (strictest) to 4 (most permissive), default 2. Requests with image or video inputs are limited to 2.

## Use Cases
- **Short videos with sound:** make social clips, ads and teasers that already include ambient sound, speech or effects.
- **Animating stills:** turn a product shot or illustration into a moving scene with `images`.
- **Storyboards:** give a sequence of keyframes and let the model fill the motion between them.
- **Longer sequences:** extend a generated or filmed shot with `start_video` and chain clips together.
- **Cheap iteration:** test prompts in `draft` mode, then render the final version at full quality.

## Visual Examples
This is a real request sent through api.market and the file it returned.

Prompt used: "A street musician plays a saxophone under a streetlight on a rainy night, warm light, the sound of saxophone and light rain"

Other inputs: `duration`: "5", `resolution`: "720p" (all other fields at their defaults, so `draft` false and `generate_audio` true).

**Output video (with audio):** [Watch the example video](https://blog.api.market/wp-content/uploads/2026/10/flux-3-output-api-market.mp4)

## Pricing
- **Pay As You Go (PAYG) pricing:** you only pay for what you use.
- **Price:** $0.075 per API unit.
- **1 API unit** = 1 second of output video, rounded up to the next whole second.
- The units per second depend on `draft`, `start_video` and `resolution`. The total is rounded up to a whole unit per request.

| Request | Units per second | Price per second | 5 second clip |
|---|---|---|---|
| `draft` true (text or images; drafts are 720p) | 1 | $0.075 | 5 units = $0.375 |
| `draft` true with `start_video` | 2 | $0.15 | 10 units = $0.75 |
| Full quality, `resolution` "720p" (text or images) | 2.834 | $0.21255 | 14.17, rounded up to 15 units = $1.125 |
| Full quality, `resolution` "1080p" (text or images) | 4.834 | $0.36255 | 24.17, rounded up to 25 units = $1.875 |
| Full quality with `start_video`, "720p" | 6.834 | $0.51255 | 34.17, rounded up to 35 units = $2.625 |
| Full quality with `start_video`, "1080p" | 8.834 | $0.66255 | 44.17, rounded up to 45 units = $3.375 |

- **Defaults:** `draft` is false and `resolution` is `720p`, so a request that sets neither bills at 2.834 units per second.
- **Duration `auto`:** the model picks the length, and you are billed for the seconds of video it returns.
- **Worked example:** the request in Visual Examples (5 seconds, 720p, full quality, no `start_video`) is 5 x 2.834 = 14.17, rounded up to 15 units = $1.125.
- **Failed or cancelled predictions** are not billed.
- **GET requests** to check prediction status (GET /api/v1/magicapi/generate-video-with-audio-from-text-images-video-black-forest-labs-flux-3/predictions/{id}) are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
`https://prod.api.market/api/v1/magicapi/generate-video-with-audio-from-text-images-video-black-forest-labs-flux-3`

### Authentication
Send your api.market API key in the `x-api-market-key` header on every request:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT:** This API is asynchronous.
1. POST `/predictions` with the model `version` and your `input`.
2. The API returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`. 201 means the request was accepted; it is not an error.
3. Poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
4. When `status` is `succeeded`, `output` holds the URL of the generated video.
5. When `status` is `failed`, the `error` field explains why.

### Endpoints

#### Create a Prediction
`POST /predictions`

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/generate-video-with-audio-from-text-images-video-black-forest-labs-flux-3/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "93515f53aad737958ca158c96e36e7f48f0197f9ba1f28fadbfb62437dcbb5ed",
    "input": {
      "prompt": "A street musician plays a saxophone under a streetlight on a rainy night, warm light, the sound of saxophone and light rain",
      "duration": "5",
      "resolution": "720p"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "f3x9mq2ld7vr0cu8b5nzpk4tyc",
  "version": "93515f53aad737958ca158c96e36e7f48f0197f9ba1f28fadbfb62437dcbb5ed",
  "status": "starting",
  "created_at": "2026-10-13T11:12:45.274Z"
}
```

#### Check Prediction Status
`GET /predictions/{id}`

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/generate-video-with-audio-from-text-images-video-black-forest-labs-flux-3/predictions/f3x9mq2ld7vr0cu8b5nzpk4tyc" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response (200 OK) once the prediction has finished:
```json
{
  "id": "f3x9mq2ld7vr0cu8b5nzpk4tyc",
  "status": "succeeded",
  "input": {
    "prompt": "A street musician plays a saxophone under a streetlight on a rainy night, warm light, the sound of saxophone and light rain",
    "duration": "5",
    "resolution": "720p"
  },
  "output": "https://blog.api.market/wp-content/uploads/2026/10/flux-3-output-api-market.mp4",
  "error": null,
  "created_at": "2026-10-13T11:12:45.274Z",
  "started_at": "2026-10-13T11:12:45.801Z",
  "completed_at": "2026-10-13T11:14:20.069Z"
}
```

### Input Parameters
| Parameter | Type | Required | Default | Allowed values | Description |
|---|---|---|---|---|---|
| `prompt` | string | Yes | none |  | Text description of the video to generate. Plain language works: the prompt is interpreted and expanded before generation. Describe the scene, action, camera moves, and any audio you want. |
| `images` | array of URLs | No | [] (empty) |  | Optional images to drive the video, placed on screen pixel for pixel. One image opens the clip (image-to-video). Two images start and end it. Three or more (up to 10) become a storyboard: the first starts it, the last ends it, and the rest fall evenly in between (needs a duration). Leave empty for text-to-video. Must be PNG, JPEG, or WebP. |
| `start_video` | string (URL) | No | none |  | A video to continue from its final frames. Use this to extend a shot or chain generations into a longer sequence. Must be an mp4, at most 50MB and 15 seconds. Can't be combined with images. |
| `aspect_ratio` | string | No | "auto" | `auto`, `21:9`, `2:1`, `16:9`, `4:3`, `1:1`, `3:4`, `9:16` | Aspect ratio of the generated video. 'auto' picks a ratio from your prompt and any inputs. |
| `resolution` | string | No | "720p" | `720p`, `1080p` | Output resolution. |
| `duration` | string | No | "auto" | `auto`, `5`, `6`, `7`, `8`, `9`, `10`, `11`, `12`, `13`, `14`, `15`, `16`, `17`, `18`, `19`, `20` | Length of the generated clip in seconds. 'auto' lets the model pick to fit the content. Three or more images need an explicit duration. |
| `generate_audio` | boolean | No | true |  | Generate synchronized audio (ambient sound, speech, effects). Set to false for a silent clip. |
| `draft` | boolean | No | false |  | Generate a fast, low-cost draft preview instead of a full-quality clip. Drafts are 720p. |
| `safety_tolerance` | integer | No | 2 | 0 to 4 | Moderation tolerance for input and output, 0 (strictest) to 4 (most permissive). Requests with image or video inputs are limited to 2. |

### Output
`output` is a single URL (string) pointing to the generated MP4 video.

## Status Codes
- **200 OK:** prediction status returned.
- **201 Created:** prediction accepted. Poll GET `/predictions/{id}` for the result.
- **400 Bad Request:** invalid or missing input fields.
- **401 Unauthorized:** missing or invalid API key.
- **404 Not Found:** unknown prediction ID.
- **429 Too Many Requests:** too many requests in a short time. Wait and retry.
- **500 Internal Server Error:** server-side error. Retry after a short wait.

## Rate Limits

All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Error Handling
- **Request errors (4xx):** check the response body, fix the input fields and send the request again.
- **Failed predictions:** when GET returns `status: "failed"`, read the `error` field. Failed predictions are not billed.
- **Rate limits (429) and server errors (5xx):** retry with exponential backoff.

## Implementation Guide

### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/generate-video-with-audio-from-text-images-video-black-forest-labs-flux-3";

async function createPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "93515f53aad737958ca158c96e36e7f48f0197f9ba1f28fadbfb62437dcbb5ed", input })
  });
  if (response.status !== 201 && response.status !== 200) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }
  return response.json();
}

async function waitForPrediction(id, timeoutMs = 1200000, intervalMs = 5000) {
  const start = Date.now();
  while (Date.now() - start < timeoutMs) {
    const response = await fetch(`${baseUrl}/predictions/${id}`, {
      headers: { "x-api-market-key": apiKey }
    });
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }
    const prediction = await response.json();
    if (prediction.status === "succeeded") return prediction.output;
    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "unknown error"}`);
    }
    await new Promise((resolve) => setTimeout(resolve, intervalMs));
  }
  throw new Error("Timed out waiting for the prediction");
}

const prediction = await createPrediction({
  "prompt": "A street musician plays a saxophone under a streetlight on a rainy night, warm light, the sound of saxophone and light rain",
  "duration": "5",
  "resolution": "720p"
});
const output = await waitForPrediction(prediction.id);
console.log(output);
```

### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/generate-video-with-audio-from-text-images-video-black-forest-labs-flux-3"

def create_prediction(input_data):
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers={"Content-Type": "application/json", "x-api-market-key": API_KEY},
        json={"version": "93515f53aad737958ca158c96e36e7f48f0197f9ba1f28fadbfb62437dcbb5ed", "input": input_data},
    )
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")
    return response.json()

def wait_for_prediction(prediction_id, timeout=1200, interval=5):
    start = time.time()
    while time.time() - start < timeout:
        response = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers={"x-api-market-key": API_KEY},
        )
        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")
        prediction = response.json()
        if prediction["status"] == "succeeded":
            return prediction["output"]
        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'unknown error'}")
        time.sleep(interval)
    raise Exception("Timed out waiting for the prediction")

prediction = create_prediction({
  "prompt": "A street musician plays a saxophone under a streetlight on a rainy night, warm light, the sound of saxophone and light rain",
  "duration": "5",
  "resolution": "720p"
})
print(wait_for_prediction(prediction["id"]))
```

### cURL
```bash
# Step 1: create the prediction (returns 201 Created with an id)
curl -X POST "https://prod.api.market/api/v1/magicapi/generate-video-with-audio-from-text-images-video-black-forest-labs-flux-3/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "93515f53aad737958ca158c96e36e7f48f0197f9ba1f28fadbfb62437dcbb5ed",
    "input": {
      "prompt": "A street musician plays a saxophone under a streetlight on a rainy night, warm light, the sound of saxophone and light rain",
      "duration": "5",
      "resolution": "720p"
    }
  }'

# Step 2: poll with the returned id until status is succeeded, failed or canceled
curl -X GET "https://prod.api.market/api/v1/magicapi/generate-video-with-audio-from-text-images-video-black-forest-labs-flux-3/predictions/f3x9mq2ld7vr0cu8b5nzpk4tyc" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## FAQ
**Q: Does the video include sound?**  
A: Yes, by default. `generate_audio` (default true) adds synchronized audio such as ambient sound, speech and effects. Set it to false for a silent clip. The price is the same either way.

**Q: How long can a clip be?**  
A: `duration` is `auto` or 5 to 20 seconds. With three or more images you must set an explicit duration.

**Q: What does draft mode cost?**  
A: 1 unit per second ($0.075), or 2 units per second ($0.15) with `start_video`. Drafts are 720p.

**Q: Can I use images and start_video together?**  
A: No. `start_video` can't be combined with `images`.

**Q: Why does start_video cost more?**  
A: Requests with `start_video` are billed at a higher rate: 2 units per second for a draft, and 6.834 (720p) or 8.834 (1080p) units per second at full quality.

**Q: Is POST returning 201 an error?**  
A: No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


Generate video with synchronized audio from text, images or video with Black Forest Labs FLUX 3, at 720p or 1080p. Billed per second, from $0.075 per second.