Use FLUX 3 Max with an AI assistant

Short answer

Use fal’s official model page for access. Choose text input, a starting image, or keyframes to match your material. An assistant can prepare the brief and integration code; execution requires a configured runtime and your fal API key. Direct Dots integration remains unverified.

What FLUX 3 Max is and where to use it

fal describes FLUX 3 Max as a post-trained version of FLUX 3 Video, developed with Black Forest Labs. It is a video model. Black Forest Labs links its Max launch section to fal. Black Forest Labs product page.

Start at the official fal endpoint that matches your input.

• Text to video for a written scene.
• Image to video for a starting image, with an optional ending image.
• Keyframes to video for image guidance at several points.

Review the selected endpoint’s form and API documentation before supplying files or running a request. This guide uses the text-to-video endpoint.

Check the price before approving a request

On October 20, fal’s text-to-video model card displayed promotional rates of $0.0425 per generated second at 720p and $0.0725 at 1080p. It listed subsequent rates of $0.17 and $0.29 respectively. Check the current model card.

At those displayed promotional rates, a five-second request calculates to $0.2125 at 720p or $0.3625 at 1080p. These are duration-times-rate estimates. They exclude other services and any account-specific billing differences.

The card states that its promotion ends November 7. The launch announcement describes a three-week promotion. Recheck the live rate before spending; do not build a recurring budget around a launch discount. fal’s October 19 announcement.

For a first attempt, approve one five-second 720p request. Decide separately whether another attempt is worth its charge. This is a suggested spending control.

Choose the settings explicitly

The current text-to-video schema permits durations from 5 to 20 seconds in whole seconds. It lists 720p and 1080p resolution options. Audio defaults to enabled. Reasoning defaults to high; fal says higher reasoning takes longer. Official endpoint schema.

Set the duration, resolution, aspect ratio, audio choice, and reasoning level explicitly. Our example selects low reasoning for a small first trial. We have not measured its quality against high reasoning.

Black Forest Labs advertises a ten-second clip generated in twelve seconds. fal’s endpoint page gives an approximately eleven-second benchmark. These vendor figures describe particular tests. They do not establish your total wait, which also depends on the queue and request settings. BFL claim · fal benchmark scope.

Give your assistant a bounded video task

A useful first assignment produces an inspectable request before it spends money. Use this brief with a coding assistant such as Codex. It still needs an appropriate runtime and API access to execute the request.

Prepare one FLUX 3 Max text-to-video request.
Use the current fal endpoint documentation.
Goal: a short product concept featuring a blue paper boat.
Set duration to 5 seconds, resolution to 720p, and aspect ratio to 16:9.
Specify one subject action, one camera instruction, and the intended sound.
Show the exact request body and the current estimated generation charge.
Wait for my approval before making any paid request.
After approval, submit once.
Preserve the request ID immediately.
Query that ID to recover progress. Do not automatically resubmit failures.
Return the result URL, settings, and any unresolved errors.
Do not publish the video.

This is an editorial task template. It is not a tested Dots connector or a guarantee that an assistant can inspect the finished video. Ask for a manual review when video inspection is unavailable.

If you already have an image, use the image-to-video endpoint and describe the movement after that frame. Recheck its input schema instead of adding image fields to this text-only example.

Submit once and keep the request ID

These Node.js examples use @fal-ai/client. Install the client in a server-side project. Store your fal key in the runtime’s FAL_KEY environment variable. Keep the key out of browser code, screenshots, and chat messages. fal client and authentication documentation.

npm install @fal-ai/client

Save the first example as submit.mjs. Running it submits a billable generation request. Approve the live price first.

import { fal } from "@fal-ai/client";
import { open, writeFile } from "node:fs/promises";

// Set FAL_KEY in the server environment before running this file.
const endpoint = "blackforestlabs/flux-3-max/text-to-video";
// Reserve this record before submitting. An existing file stops another run.
const record = await open("flux-request.json", "wx");
await record.writeFile(JSON.stringify({ endpoint, state: "submitting" }));
await record.close();
const { request_id } = await fal.queue.submit(endpoint, {
  input: {
    prompt: "A blue paper boat floats across a shallow bowl. " +
      "The camera stays still. Soft daylight. Gentle water sounds.",
    duration: 5,
    resolution: "720p",
    aspect_ratio: "16:9",
    generate_audio: true,
    reasoning_level: "low"
  }
});
// Keep this ID if local saving fails. Do not submit again to recover it.
console.log("Request ID:", request_id);
await writeFile("flux-request.json", JSON.stringify({ endpoint, request_id }, null, 2));

Download submit.mjs. Run it from your project directory with node submit.mjs. The script reserves flux-request.json before submission. An existing record stops another run. It prints the request ID before updating the record. Keep that ID if saving fails.

Save the second example as recover.mjs in the same directory. Run node recover.mjs to inspect the saved request.

import { fal } from "@fal-ai/client";
import { readFile, writeFile } from "node:fs/promises";

const endpoint = "blackforestlabs/flux-3-max/text-to-video";
const request_id = process.argv[2] || JSON.parse(
  await readFile("flux-request.json", "utf8")
).request_id;
if (!request_id) {
  throw new Error("No request ID saved. Check fal request history before resubmitting.");
}
const status = await fal.queue.status(endpoint, { requestId: request_id });
console.log("Status:", status.status);
if (status.status === "COMPLETED") {
  const result = await fal.queue.result(endpoint, { requestId: request_id });
  if (!result.data?.video?.url) throw new Error("No video URL returned. Inspect this request in fal.");
  await writeFile("flux-result.json", JSON.stringify(result.data, null, 2));
  console.log("Video URL:", result.data.video.url);
} else {
  console.log("Check this same request later. Do not submit a replacement.");
}

Download recover.mjs. While the request is queued or running, check the same ID later. When the request succeeds and returns a video URL, the script saves flux-result.json and prints that URL. Download the video promptly; this guide makes no storage-duration promise.

If you have the console ID but no usable record, run node recover.mjs YOUR_REQUEST_ID. Replace the placeholder with that original ID. If submission fails before an ID arrives, check fal’s request history first. A timeout does not establish that submission failed. Keep the reserved record until the request is resolved.

If the API returns an error, preserve the ID and error details. Inspect the request in fal before deciding to retry. These scripts omit application-level rate limits, storage, and user authentication. They are documentation examples, not a production integration.

Review the clip against the brief

For the paper-boat example, check whether the boat stays blue, the camera remains still, and the requested water sound is present. These are proposed acceptance checks. We have not generated or inspected this clip.

For an application, save the request ID before waiting for completion. Record the settings and result location with the task. Mark delivery complete only after the result is available. A submitted request alone does not prove that a usable video exists.

Need help writing the task? Read our first-task guidance. For an incomplete result, compare the saved output with the brief before authorizing another request.

FAQ