Research-backed calculator guide

fal AI Pricing Units: Cost per Image, Megapixel, Video Second or Request

Use a fal AI output-unit pricing calculator to estimate image, megapixel, video-second, request, and GPU-time spend without mixing unlike billing meters.

A fal AI bill is not one universal “cost per generation.” The meter depends on the endpoint: one model may charge per image, another per megapixel, another per video second, and another per request or compute second. The safe way to estimate spend is to identify the endpoint’s billing unit first, multiply only like units, and keep any retry or variant allowance visible.

The five meters to keep separate

Per image

A per-image endpoint has the simplest first-pass formula:

cost = price per image × number of billable images

If the current endpoint price is $0.08 per image and the workload requests 800 images, the base arithmetic is 800 × $0.08 = $64. That figure is before retries, extra variants, or account-specific discounts. “Per image” does not mean every model configuration is interchangeable. Resolution, quality, output count, or a model-specific option can change the endpoint’s quoted unit or quantity, so record the exact model ID and input settings beside the estimate.

Per megapixel

A megapixel meter follows output area rather than image count. The planning formula is:

cost = price per MP × billable MP per output × output count

Raw pixel math can help with a first estimate: width × height ÷ 1,000,000 = megapixels. A 1,024 × 1,024 image contains 1.048576 MP by that raw calculation. However, do not assume raw dimensions are the provider’s final billable quantity. The endpoint may normalize a preset, apply a minimum, round a value, or expose a different contract. fal’s documentation says higher resolutions can cost proportionally more for megapixel-priced image models. ^[1] Treat your dimension calculation as a planning input until the endpoint’s current quote or usage line confirms the actual quantity.

A useful fal megapixel pricing calculator therefore stores both requested width × height and billable MP used in the estimate. If those values differ, show why. Hiding the conversion makes a larger production canvas look artificially cheap.

Per video second or per video

For a per-second video endpoint, use generated duration, not request count:

cost = price per video second × generated seconds

A five-second clip at $0.05 per second is $0.25 before any retry allowance. Ten requests do not necessarily equal ten billable seconds: each request may produce a different duration, and a model with a flat per-video meter follows a different formula. fal’s public pricing page shows video models with output-based units such as seconds and notes that the comparable output can vary by model, resolution, and prompt complexity. ^[2] Store resolution and duration in the estimate so a 1080p revision is not silently compared with a 480p draft.

Per request or provider-specific output unit

Some endpoints use a request, token, credit, generation, or another provider-defined unit. Use the unit returned for that endpoint rather than forcing it into “images.” fal’s pricing API returns an endpoint ID, unit price, unit, and currency, and requires an authenticated API key. ^[3] That response is useful for a live application because it prevents a stale spreadsheet label from surviving a model change.

If the endpoint is priced per request, the base formula is unit price × successful billable requests. If it is priced per 1,000 tokens or credits, keep the denominator in the unit name. For example, $0.014 per 1,000 tokens is not $0.014 per token; the quantity must be expressed in thousands before multiplication.

GPU or compute second

A hosted output price and a custom deployment price answer different questions. fal’s documentation says some Serverless or less common models fall back to GPU or compute-based billing, while hosted Model APIs commonly expose output units. ^[1] A GPU-second estimate needs machine type, billed runner time, concurrency behavior, and the amount of work each runner completes. Do not estimate a custom deployment by multiplying a hosted model’s per-image price.

For a compute meter, use:

cost = hourly GPU rate ÷ 3,600 × billed GPU seconds

Include cold-start, warm-run, idle, and scale-to-zero assumptions only when the relevant Serverless contract confirms how those states are billed. If you do not have those inputs, label the result a scenario estimate rather than a fal quote.

Worked cost example

The following is an original planning table, not a live invoice. It uses three public pricing-page observations checked on November 2, 2026: Nano Banana 2 at $0.08 per image, Z Image Turbo at $0.005 per megapixel, and MiniMax H3 Max reference-to-video at $0.05 per second. The public page presents model-specific prices and says image comparisons may be normalized to 1 MP; it also warns that actual output can vary by model and resolution. ^[2]

Assumptions: 800 per-image outputs, 2,400 billable MP across an image-area workload, 180 generated video seconds, and a 12% allowance for retries or extra variants. The allowance is a planning assumption chosen for this example. It is not a fal fee.

The base subtotal is $85.00. The retry and variant buffer is 85 × 0.12 = $10.20, producing a planning budget of $95.20. The table can be expanded with a separate row for requests, audio seconds, or GPU time, but each row should retain its own unit and assumptions.

Suppose instead that the image-area workload is described as 600 square 1,024-pixel outputs. Raw area is 600 × 1.048576 = 629.1456 MP. At the illustrative $0.005 rate, raw-area arithmetic gives about $3.15 before any provider rounding or endpoint-specific rule. That is not permission to invoice $3.15 as settled usage. It is a transparent sensitivity case showing why a 1 MP shortcut can understate a larger output. Query the endpoint or inspect usage after the run before treating the quantity as final.

How to get a current endpoint quote

Start with the exact endpoint ID, not a family name such as “Flux” or “Kling.” The fal pricing API accepts one or more endpoint IDs and returns the unit price, unit, and currency for each requested endpoint. ^[3] Record the response timestamp, endpoint ID, selected options, and currency in the estimate ledger.

For a batch known in units, fal documents a pricing-estimate endpoint that can use a unit price multiplied by expected billing units. It also describes a historical API-price method based on call quantity. ^[4] These methods answer different questions:

• Use a unit-based estimate when you know the expected number of images, megapixels, video seconds, or another billing unit.
• Use a historical call estimate when you have prior per-call usage patterns and want a planning view based on calls.
• Use neither as a substitute for settled usage when the endpoint, account discount, retry behavior, or output quantity changed.

A production estimator should fail closed when the unit is unknown. Rather than returning a misleading “cost per image,” show unit unavailable and ask for a fresh endpoint response. This is especially important when a catalog mixes per-image and per-megapixel models. The numerical output can look precise while the unit label is wrong.

Retries, successful outputs, and reconciliation

A clean one-shot formula is not the same as cost per accepted asset. Track at least four quantities: requested outputs, attempts, successful billable outputs, and accepted outputs after review. Then calculate both base provider cost and operational cost per accepted result.

The fal Model API documentation says server errors and queue waiting time are not charged for Model API outputs, while successful outputs are billed according to the endpoint’s unit. ^[1] That does not make every failure scenario free across every fal product. A validation failure, a client retry, or a compute-based deployment can follow a different rule. Keep the product path and error class in your ledger, and do not generalize a hosted-output rule to GPU-time billing.

For accepted-output economics, use:

cost per accepted output = settled provider cost ÷ accepted outputs

If 1,000 requested images produce 920 accepted assets after revisions, divide the settled amount by 920, not 1,000. This metric belongs beside the list-price estimate, not in place of it. It explains why a model with a lower nominal unit price can still produce a higher usable-asset cost when it needs more retries or manual repair.

For a broader monthly forecast, link the unit estimate to the LLM cost calculator only when the same workflow also invokes a language model. Use the AI token cost calculator for token-metered prompt or review steps instead of adding tokens to fal’s image row. After the work completes, use AI API invoice reconciliation to compare the estimate with provider usage and the invoice line.

Limitations and exclusions

This guide does not quote a guaranteed rate for your account. Public prices can change, enterprise or account-specific discounts can apply, and the estimate endpoint requires authentication. ^{[3] [4]} Refresh the price at the time of budgeting and preserve the date.

It also does not infer image quality, latency, safety performance, commercial rights, or acceptance rate from a unit price. A cheaper megapixel is not automatically cheaper per approved asset. Test the endpoint with representative prompts and record output count, resolution, retries, and acceptance.

Taxes, payment fees, storage, egress, downstream moderation, human review, and application infrastructure are excluded unless you add them as separate rows. A fal output-unit estimate is one provider-cost layer, not a complete feature or SaaS cost model. For a complete workflow, combine this estimate with application calls, review labor, and reconciliation evidence.

FAQ

How do I calculate fal AI cost per image?

Find the exact endpoint’s current per-image unit price and multiply it by the number of billable images. Then add a separately labeled allowance for retries or variants. If the endpoint is actually per megapixel, do not use image count alone; calculate billable output area first. Confirm the final amount with endpoint usage because public list-price arithmetic may not include account-specific pricing or configuration rules. ^{[1] [3]}

How does a fal megapixel pricing calculator convert image dimensions?

Multiply width by height and divide by 1,000,000 to get raw megapixels. For 1,024 × 1,024, that is 1.048576 raw MP. Multiply the raw or endpoint-confirmed billable MP by the per-MP price and by the number of outputs. Use raw MP as a planning assumption only when the model contract does not provide a more specific quantity. fal notes that higher resolution can be priced proportionally, but the endpoint’s own normalization or rounding rule controls the final bill. ^{[1] [2]}

How do I estimate fal video generation cost per second?

Multiply the model’s current price per generated second by the expected generated duration. For example, 180 seconds at an illustrative $0.05 per second gives a $9 base subtotal. Keep resolution, duration, and model ID in the input record because video rates and meters are model-specific. If the model charges a flat amount per video, replace seconds with the number of videos; do not convert between the two without an endpoint rule. ^{[1] [2]}

Are fal queue time and failed requests charged?

For fal Model APIs, the pricing documentation says server errors and time waiting in the queue are free, and successful outputs are billed by the model’s defined unit. ^[1] That statement should not be extended automatically to validation errors, client retries, Serverless GPU time, or a different fal product. Classify the error and product path, then confirm the current contract before setting a retry policy.

Is fal Serverless pricing the same as hosted Model API pricing?

No. Hosted Model APIs commonly bill the generated output, while Serverless or other custom deployments can bill GPU or compute time by the second. ^{[1] [3]} Use output-unit arithmetic for a hosted endpoint and compute-time arithmetic for a custom deployment. If a workload may switch between the two, model them as separate scenarios rather than averaging the rates.

Can fal’s pricing API replace invoice reconciliation?

It can provide a current endpoint unit price for an estimate, and fal also documents an estimate endpoint for unit or historical call quantities. ^{[3] [4]} It does not remove the need to compare estimates with settled usage, discounts, retries, and invoice records. Keep the endpoint response, estimate timestamp, request quantities, and final usage line together so a later variance has an explainable cause.