# fal API for AI agents: what an image, a clip and a voice-over cost per output

> How an agent runs fal's hosted image, video and speech models, what the queue returns, and the per-megapixel and per-second arithmetic behind each call.

- Published: 2026-11-02
- Author: AMXP
- Topic: Media generation
- Tags: #fal #ai-agents #image-generation #video-generation #text-to-speech #flux #kling #pricing
- Canonical: https://amxp.ai/blog/fal-api-for-ai-agents

When an agent needs a picture, a short clip or a voice-over, fal is one API in front of hundreds of
generation models. Each model is an endpoint ID such as `fal-ai/flux/schnell`: you send JSON, you get
back URLs to the files, and you pay per output rather than per month. The catch is that "per output"
means something different for every model. By the end of this guide you will know why 100 FLUX
schnell images cost $0.30 while 100 Nano Banana images cost $3.98, and why one default-settings Kling
clip costs as much as 233 schnell images.

- **$0.003** per megapixel, FLUX.1 [schnell] (rounded up, Oct 2026)
- **$0.14** per second, Kling 2.6 Pro with audio ($0.07 with audio off)
- **2** concurrent requests on a new account (self-serve max 40)
- **$0** for HTTP 500+ and queue time (only inference is billed)

## Why this matters for agents

A person generating images clicks, looks, and clicks again. An agent generates in loops, and three
things about fal change the cost of those loops.

First, the unit of billing is not the request. Image models bill per image or per megapixel, video
models per second of output, speech per 1,000 characters, and a few models fall back to GPU seconds
([Model API pricing](https://fal.ai/docs/model-apis/pricing)). An agent that picks a bigger
`image_size` or flips `generate_audio` has changed the price without changing the number of calls.

Second, concurrency is tight at the start. Every new account begins with a limit of 2 concurrent
requests, and self-serve limits scale up to 40 based on paid invoices from the last four weeks
([rate limits](https://fal.ai/docs/model-apis/rate-limits)). Over the limit you get a 429 with
`X-Fal-needs-retry: 1`. The queue requeues `submit` and `subscribe` calls with no maximum retry
count, so a 50-image batch at concurrency 2 does not fail, it just takes 25 rounds.

Third, failures are cheap but not free of consequence. fal does not charge for HTTP 500 and above or
for time in the queue ([pricing](https://fal.ai/docs/model-apis/pricing)). But a request that
succeeds with an image your safety checker flagged is still a successful output, and so is a video
from a prompt you typed wrong. Validate the prompt before the call, not after.

Before spending, an agent should check the model page's unit price, the endpoint's default values
(they are often the expensive ones), and whether the job needs the queue.

## What fal returns

Every model has its own schema, but the shapes repeat. [FLUX.1 [schnell]](https://fal.ai/models/fal-ai/flux/schnell)
returns:

| Field | What it is |
| --- | --- |
| `images[]` | Each with `url`, `width`, `height` and `content_type` |
| `seed` | The seed used, so you can reproduce the result |
| `has_nsfw_concepts[]` | One boolean per image from the safety checker (`enable_safety_checker` defaults to true) |
| `prompt` | The prompt that was run |
| `timings.inference` | Seconds spent on inference |

Video models such as [Kling Video v2.6 Pro](https://fal.ai/models/fal-ai/kling-video/v2.6/pro/text-to-video)
return a single `video` object with `url`, `content_type`, `file_name` and `file_size`. Speech
models such as [MiniMax Speech 2.8 [HD]](https://fal.ai/models/fal-ai/minimax/speech-2.8-hd) return
`audio.url` and nothing else: no duration, no character count. If you need either, measure the
file yourself.

Three surprises. The URLs point at hosted files on `fal.media`, so download anything you intend to
keep. [Nano Banana](https://fal.ai/models/fal-ai/nano-banana) returns a `description` field that is
empty in fal's own example. And when a job runs through the queue, the response you poll for has a
`status` of `IN_QUEUE` (with `queue_position`), `IN_PROGRESS` or `COMPLETED`; a failed request still
reaches `COMPLETED` and carries `error` and `error_type`, so check for `error` before reading
`images` ([Queue API](https://fal.ai/docs/model-apis/model-endpoints/queue)).

## The economics

fal prices "per output, per model" and draws from prepaid credits ([fal pricing](https://fal.ai/pricing)).
List prices as of October 2026, from each model's page:

**100 images at one megapixel each** (fal list prices, October 2026)

| Item | Value |
| --- | --- |
| FLUX.1 [schnell] | $0.3 |
| FLUX.1 [dev] | $2.50 |
| Ideogram V3 Turbo | $3 |
| Nano Banana | $3.98 |
| FLUX1.1 [pro] | $4 |
| Ideogram V3 Quality | $9 |

Source: [fal pricing](https://fal.ai/pricing). Per-megapixel models at exactly 1 MP; Nano Banana and Ideogram bill per image. Model pages in References.

**The megapixel multiplier.** [FLUX.1 [schnell]](https://fal.ai/models/fal-ai/flux/schnell) costs
"$0.003 per megapixel" and "images are billed by rounding up to the nearest megapixel".
[FLUX.1 [dev]](https://fal.ai/models/fal-ai/flux/dev) is $0.025 per megapixel and
[FLUX1.1 [pro]](https://fal.ai/models/fal-ai/flux-pro/v1.1) is $0.04, with the same rounding. So:

- Default `image_size` of `landscape_4_3` is 1024 × 768 = 0.79 MP, which rounds up to 1 MP:
  $0.003 per schnell image, $0.30 per 100.
- A 1536 × 1536 image is 2.36 MP, which rounds up to 3 MP: $0.009 per schnell image, three times
  the price for 2.25 times the pixels.
- `num_images: 4` (the maximum on schnell) is four outputs, four charges.

**Per-image models.** [Nano Banana](https://fal.ai/models/fal-ai/nano-banana) is a flat "$0.0398"
per image. [Ideogram V3](https://fal.ai/models/fal-ai/ideogram/v3) depends on `rendering_speed`:
"$0.03 with TURBO, $0.06 with BALANCED, and $0.09 with QUALITY". Same prompt, 3x price.

**The per-second multiplier.** Video is where cost compounds, because two parameters multiply:

**Shortest clip each model will make** (Text to video on fal, October 2026)

| Item | Value |
| --- | --- |
| Kling 2.6 Pro, 5 s, no audio | $0.35 |
| Hailuo 02 Pro, 6 s | $0.48 |
| Kling 2.6 Pro, 5 s, audio on | $0.7 |

Source: [Kling Video v2.6 Pro text to video](https://fal.ai/models/fal-ai/kling-video/v2.6/pro/text-to-video). Hailuo 02 Pro from its own model page; see References.

[Kling 2.6 Pro](https://fal.ai/models/fal-ai/kling-video/v2.6/pro/text-to-video) charges "$0.07
(audio off) or $0.14 (audio on)" for every second. In the endpoint's schema, `duration` defaults to
`"5"` and `generate_audio` defaults to `true`, so a call with just a `prompt` costs 5 × $0.14 =
$0.70, exactly fal's own example. Set `duration: "10"` and it is $1.40. Turn audio off and the same
10 seconds cost $0.70. [Hailuo 02 Pro](https://fal.ai/models/fal-ai/minimax/hailuo-02/pro/text-to-video)
is "$0.08/sec", and its shortest clip is 6 seconds, so "a single 6 second video will cost
$0.48/video".

**Speech.** [MiniMax Speech 2.8 [HD]](https://fal.ai/models/fal-ai/minimax/speech-2.8-hd) is "$0.1
per 1000 character". A 60-second voice-over is roughly 900 characters, so about $0.09; a 20,000-word
article (about 120,000 characters) is $12.

Putting it together for a product-listing agent that makes 1 hero image, 3 variations and one
5-second clip per product: 4 schnell images at 1 MP = $0.012, plus one Kling clip with audio off =
$0.35, so $0.36 per product and $36 per 100 products. Leave audio on and it is $71.

## How to call it from your agent

AMXP is in private preview. Once it opens, the agent searches for the job, reads the model's schema
and unit price, then runs it with fal's own parameter names:

```ts
const [tool] = await amxp.discover({ query: "fast text to image", provider: "fal" })
const spec = await amxp.inspect(tool.id)   // schema, defaults and price per megapixel
const run = await amxp.execute(tool.id, {
  prompt: "A ceramic coffee mug on a walnut desk, soft morning light",
  image_size: "landscape_4_3",   // 1024 x 768, rounds up to 1 megapixel
  num_images: 1,
  num_inference_steps: 4,
  output_format: "jpeg",
  enable_safety_checker: true,
})
// run.output.images[0].url, run.output.has_nsfw_concepts[0]
```

The direct call with fal's client. `subscribe` submits to the queue and polls until the result is
ready, which is the right default for anything that takes more than a few seconds:

```ts
import { fal } from "@fal-ai/client"

const result = await fal.subscribe("fal-ai/kling-video/v2.6/pro/text-to-video", {
  input: { prompt: "Slow pan across a walnut desk", duration: "5", generate_audio: false },
})
// result.data.video.url
```

Raw HTTP authenticates with `Authorization: Key $FAL_KEY` and submits to
`https://queue.fal.run/<endpoint>`, which returns `request_id`, `status_url`, `response_url` and
`cancel_url` ([Queue API](https://fal.ai/docs/model-apis/model-endpoints/queue)).

## What most people get wrong

**Polling status in a tight loop.** The queue has a `/status/stream` endpoint that sends
server-sent events until the request completes, and a `webhook_url` option that POSTs the result
to you ([Queue API](https://fal.ai/docs/model-apis/model-endpoints/queue)). Use one of those for
video. If you must poll, back off: fal's own 429 guidance is exponential, 1 s, 2 s, 4 s, 8 s
([rate limits](https://fal.ai/docs/model-apis/rate-limits)).

**Trusting the defaults on video.** Kling 2.6 Pro defaults to audio on. That one boolean doubles
every clip. Set `generate_audio` explicitly, and set `duration` explicitly too.

**Sizing images by aspect ratio, not megapixels.** Because fal rounds up to the whole megapixel, a
1.1 MP image costs the same as a 2 MP one. Either stay at or under 1 MP, or use the full 2 MP you
are paying for.

**Treating `COMPLETED` as success.** A failed queue request also reports `COMPLETED`, with `error`
and `error_type` in the body. Read `error` first.

**Retrying on your side when fal already retries.** Failed requests are requeued "up to 10 times"
and concurrency 429s are requeued without limit. Adding your own retry loop multiplies work and,
for non-idempotent webhooks, duplicates results. Use `request_id` as the idempotency key, and send
`X-Fal-No-Retry: 1` if you want to own retries yourself.

## When to use something else

- **Your own fal account** if fal is most of your media spend. Concurrency rises with paid
  invoices, so a $500-a-month account gets far more parallelism than a per-call marketplace user,
  and you can deploy your own models on fal's serverless GPUs.
- **[Replicate](/tools/replicate)**, **[Runware](/tools/runware)** or
  **[WaveSpeedAI](/tools/wavespeedai)** when the model you want is hosted there and not on fal, or
  when the same model is cheaper there for your resolution.
- **[Kling](/tools/kling)** or **[MiniMax](/tools/minimax)** directly when you only use one video
  family and want the vendor's newest options first.
- **[ElevenLabs](/tools/elevenlabs)** when voice is the main job and you need voice cloning and
  per-character pricing tuned for long scripts.
- **[Topaz Labs](/tools/topaz-labs)** to upscale an image or clip you already have, instead of
  regenerating at a higher megapixel count.
- **[Stability AI](/tools/stability-ai)** or **[Recraft](/tools/recraft)** when you want the model
  vendor's own endpoint and billing.

## Common questions

### How does fal charge for images?

Per output. FLUX models bill per megapixel, rounded up to the nearest whole megapixel, so a
1024 × 768 image is billed as 1 MP. Nano Banana and Ideogram bill a flat price per image. The unit
and price are on each model's page, and `GET https://api.fal.ai/v1/models/pricing?endpoint_id=...`
returns them as JSON ([Model API pricing](https://fal.ai/docs/model-apis/pricing)).

### Do failed fal requests cost money?

HTTP 500 and above are never billed, and queue waiting time is free. A request that returns a result
you do not like is billed like any other.

### Can my agent call fal through AMXP today?

Not yet. AMXP is in private preview, and its API, CLI and MCP server are not public. The flow above
shows how it works through AMXP once it opens.

## References

1. [fal pricing](https://fal.ai/pricing), fal
2. [Model API pricing](https://fal.ai/docs/model-apis/pricing), fal
3. [Queue API](https://fal.ai/docs/model-apis/model-endpoints/queue), fal
4. [Rate limits and concurrency](https://fal.ai/docs/model-apis/rate-limits), fal
5. [FLUX.1 [schnell] API](https://fal.ai/models/fal-ai/flux/schnell), fal
6. [FLUX.1 [dev] API](https://fal.ai/models/fal-ai/flux/dev), fal
7. [FLUX1.1 [pro] API](https://fal.ai/models/fal-ai/flux-pro/v1.1), fal
8. [Nano Banana API](https://fal.ai/models/fal-ai/nano-banana), fal
9. [Ideogram V3 API](https://fal.ai/models/fal-ai/ideogram/v3), fal
10. [Kling Video v2.6 Pro text to video](https://fal.ai/models/fal-ai/kling-video/v2.6/pro/text-to-video), fal
11. [MiniMax Hailuo 02 Pro text to video](https://fal.ai/models/fal-ai/minimax/hailuo-02/pro/text-to-video), fal
12. [MiniMax Speech 2.8 [HD] API](https://fal.ai/models/fal-ai/minimax/speech-2.8-hd), fal