Fal API Alternative (2026): Pricing vs Kinovi & Migration Guide
A model-by-model look at the fal API and Kinovi, with token-based Seedance pricing, per-second Kling and Wan rates, monthly cost scenarios, and a migration path that leaves the fal queue intact.

On this page
- Start with the conclusion
- What the fal API actually is
- Why teams look for a fal API alternative
- Six things worth comparing
- Model-by-model pricing
- A month of cost
- Migrating the integration
- Billing, refunds, and retention
- When you should stay on fal
- Other alternatives worth knowing
- Who Kinovi is for
- FAQ
- Get started
In this guide
It starts with when Kinovi is worth trying and when you should stay on fal. Then it explains how the fal API bills, the point at which teams usually start comparing, and a model-by-model alignment of video and image prices. Reference-video jobs are calculated as a full order of 5 seconds of output plus 5 seconds of reference, and the article spells out that 2.5 and 2.0 count billed seconds differently. The three monthly workloads use the current prices shown on today’s pages, with list prices noted separately. After that come a migration example, refunds and concurrency, and the cases where you should not migrate.
Start with the conclusion
If your product mostly runs Seedance 2.5 and Nano Banana, and you want a single createTask request format and a balance that does not expire, Kinovi is worth trying. If you depend on 4K Kling, Veo 3.1, FLUX 3 Max, 3D, or deploying your own models, fal is still the better fit. Don’t judge Wan 3.0 by the current prices in the summary table alone: today’s public discount is about 12% lower, while the strikethrough list price is about 33% higher. Neither side is cheaper across the whole catalog; the comparison has to land on a specific model and resolution.
| Dimension | Kinovi | fal |
|---|---|---|
| Model focus | Video, image, and audio (Seedance, Kling, Wan, Nano Banana, Seedream, Suno) | A broader multi-category catalog, including 3D, realtime, and more partner models |
| Host your own models | Not offered | Serverless / Compute, billed per GPU-second |
| Request pattern | createTask → recordInfo, same envelope for every model | Sync + queue; the schema changes by endpoint |
| Rows already checked where the price is better | Seedance 2.5 and 2.0 standard (no reference video), Kling 4.0 current price (no 4K), Wan 3.0 / Prime current prices, H3 Max and Turbo (same-resolution comparison), Nano Banana Pro / 2, and HappyHorse 720p | Standard MiniMax H3 at 768p, 4K Kling, Veo 3.1, FLUX 3 Max, PixVerse, and LTX; at list price, Wan is also lower on fal |
Route by model, rather than migrating the whole stack. Seedance 2.5, Nano Banana, and same-resolution H3 Max / Turbo can go on Kinovi; 4K Kling, Veo, FLUX 3 Max, and deploying your own models stay on fal. For Wan, first estimate this month’s bill at the current price, then make a second budget at list price for after the discount ends. Keep one internal job table on both sides, and record which platform handled each id.
When a newly released model is needed, many teams open fal first. Its catalog updates quickly, and the queue can hold a request for a long time without dropping it. Neither of those facts tells you what a given job will cost.
Here’s a comparison on a per-request basis: one 5-second, 16:9, 720p Seedance 2.5 job, one 10-second 1080p Wan 3.0 job, and one 2K Nano Banana Pro image. On fal, Seedance 2.5 is deducted from prepaid credits by output tokens, and those credits expire after a year; the token count changes with frame width, height, and duration, duration or aspect_ratio is set to auto, even the same “5-second 720p” bill may not match. On Kinovi, the same model reserves credits by output seconds, and the balance does not expire. Some rows are cheaper on fal, some on Kinovi; look at how the bill is calculated before you look at the unit price.
What the fal API actually is
- The platform is three businesses plus an API layer. fal.ai positions itself as a generative media platform; the API is only one part of it.Model API is the marketplace: more than 1,000 endpoints covering video, image, audio, and 3D, most of them built by partner labs and hosted by fal.Serverless lets you deploy your own models behind the same queue.Compute rents GPUs by the hour for training. The fourth piece is the Platform API, which exposes model metadata, pricing, usage, logs, files, and metrics.
- Authentication is a single request header. Create a key in fal.ai/dashboard/keys and send it in the request header as
Authorization: Key $FAL_KEY. Official Python and JavaScript clients are provided, and every endpoint page also includes a cURL example, so you can call REST directly without an SDK. - The same model has both a sync path and a queue path. The sync path is
https://fal.run/<endpoint_id>, and the connection stays open until the result comes back. The queue path ishttps://queue.fal.run/<endpoint_id>: after you submit, it returns arequest_id, plus ready-madestatus_url,response_urlandcancel_url. Request states are IN_QUEUE, IN_PROGRESS or COMPLETED;GET …/requests/{id}fetches the result, andGET …/requests/{id}/status/streamkeeps an SSE connection open until the job finishes. - Webhooks are a query parameter, not a separate product. Add
?fal_webhook=<url>when you submit, or passwebhookUrlin the SDK, and fal will POST the result to your service. Thestatusin the callback is OK or ERROR, not a queue state; delivery can be duplicated, so deduplicate byrequest_id. - The queue retries on its own; you set the timeouts. Requests that return 503, 504, or a connection error are re-queued, for up to ten retries;
X-Fal-No-Retry: 1turns retries off per request. On submit, usestart_timeoutto set a server-side deadline for “start processing.” Each processing attempt is bounded by the application-levelrequest_timeoutconstraint, which defaults to 3,600 seconds. Requests are not dropped, and the queue has no capacity cap—so a batch submitted at midnight is usually still there the next morning. - Billing is by endpoint unit, and credits expire after a year. The unit for prepaid credits changes by endpoint: per image, per megapixel, per video-second, per thousand tokens, per request, or, for serverless and fallback runtimes, per GPU-second. Purchased credits expire 365 days from the purchase date; promotional credits commonly last 90 days. Once the balance falls below the lock threshold, the account is locked and the API rejects jobs. Server errors (5xx) are not billed, and neither is queue time or a cold start; client errors (422) may still be billed if the GPU already ran.
- Concurrency and output retention decide whether batch jobs can actually run. New accounts start at 2 concurrent jobs and rise automatically with top-ups to a cap of 40, and higher than that you go through sales; overflow requests wait in the queue instead of failing. Outputs land on fal’s CDN and by default are kept for at least 7 days; URLs are public by default. Per request you can use
X-Fal-Object-Lifecycle-Preferenceto adjust lifecycle and access, and the account can also configure a media expiration policy. - Cost engineering has dedicated endpoints.
GET https://api.fal.ai/v1/models/pricing?endpoint_id=…returns endpoint prices, andGET https://api.fal.ai/v1/account/billing?expand=creditsreturns the current balance (both require an Admin key). If you want to build your own gross-margin calculator, this is a genuine advantage.
Why teams look for a fal API alternative
Teams usually start comparing not because a promotional price convinced them, but because one of six concrete problems pushed them there. Below they are ordered by how often they actually show up, with why each happens and what it can look like on your own bill.
- Token bills are hard to predict. The most common trigger is a token bill higher than estimated, often when nobody changed the prompt. fal’s Seedance 2.5 bills by output tokens: tokens = (height × width × duration × 24) / 1024, and both 480p and 720p are $0.0214 per thousand tokens. A 5-second 16:9 720p job is 108,000 tokens, or about $2.31. Once you know the formula it is easy to compute, but you would never see that from a price table that says “Seedance, some version, from $0.11/s.” The bigger problem is that
durationandaspect_ratiodefault toauto: a wide frame or an automatic duration both change the token count, so a “5-second 720p” estimate can fail even when nobody changed the prompt. Two teams running the “same” 720p Seedance job can see bills differ by 40%, and the reason is usually here. - Credits expire after 365 days. Credits purchased on fal expire 365 days from the purchase date, and promotional credits commonly last 90 days. If you top up $1,000, spend $600 within a year, and leave $400 sitting unused, the $600 you used effectively cost $1.67 per dollar of credit. That only holds when the balance crosses the 12-month window; it is not a surcharge on every job. Teams that prototype in bursts or run seasonal campaigns do run into it. When the balance also falls below the lock threshold, jobs are rejected outright, which is most likely around monthly close.
- Concurrency starts at 2 and rises with spend. New accounts start at 2 concurrent jobs and rise automatically to 40 with spend; higher than that, you go through sales. Two concurrent jobs are enough for prompt testing and not much else. At about 75 seconds of wall-clock time per 10-second 1080p job, 2,000 jobs take 21 hours at 2 concurrent slots and about 1 hour at 40. fal does not drop requests—the overflow queues—so the limit shows up as latency rather than errors. The scheduling cost is still real.
- Outputs are kept for only 7 days, and URLs are public by default. fal’s outputs are kept for at least 7 days by default, and URLs are public by default. 7 days is enough to download a batch, not enough to treat the CDN as storage. A public URL means the product either adds a signing proxy or sets
X-Fal-Object-Lifecycle-Preference. Neither is difficult, but both are work that never shows up on a price list before you migrate. - Version rollovers mean repeated acceptance testing. fal lists Seedance 1.0 Pro Fast, Seedance 2.0 Fast, and Seedance 2.5 at the same time, and the three bill in different ways. Kling runs from v2.5 Turbo Pro and v2.6 to v3, and 4.0 is already in the catalog—each generation a separate endpoint and a separate price. That richness is the product, but it also means every locked version has to be re-priced and re-sampled whenever the catalog updates. For a team that only calls two models a year, that maintenance is a net cost.
- Platform capabilities are a mismatch for actual usage. fal’s real strengths are Serverless and Compute: deploy, fine-tune, bill by GPU-second, plus realtime and streaming. If your product only calls four ready-made endpoints, you use none of that, and you still pay the platform complexity—billing by unit, reading a schema per endpoint, pinning versions in the endpoint. On the Kinovi side there is only one
createTaskenvelope and a credits balance that does not expire. That simplification is a gain for teams that only call ready-made models.
None of these six points means fal is a poor choice. Retries, requests that are not dropped, pricing and usage APIs, and sync calls are genuinely better than on most hosted APIs, and leaving them has a cost. The rest of this article prices that trade, rather than assuming it is a bargain.
Six things worth comparing
- The price of the job you will actually run—model version, resolution, duration, the audio toggle, and whether a reference video is included in billing.
- Whether that exact version is in the catalog—not just the family name.
- The job contract: whether every model shares one request envelope or each endpoint has its own schema, and how webhooks and cancellation behave.
- How much concurrency you get on day one, how it increases, and where overflow requests go.
- Where the money sits: credits or dollars, whether they expire, and what is refunded on failure.
- How long outputs live, whether URLs are public, and what the platform retains.
Model-by-model pricing
This section aligns the models both platforms currently sell, one by one. Prices are self-serve USD, checked on November 20, 2026. fal prices come from each endpoint page. For token-billed models such as Seedance 2.5, the published formula and 16:9 pixel dimensions are converted into a per-second price, marked “approx.” in the tables. Endpoint pages also print rounded per-second list rates that are not exactly equal to the converted figures; this article consistently compares using the formula results, and notes the page’s listed rate the first time it appears. Kinovi’s USD prices come from the published figures on each model page.
Every row in the summary tables states the resolution and whether a reference video is included, so you can judge the order of magnitude; for budgeting, see the tiered tables later, broken out by family. Kinovi lists both discounted current prices and strikethrough list prices for Wan and Kling. Monthly costs use current prices, with list-price totals noted separately. Differences use fal as the baseline; a negative sign means Kinovi is lower on that row. Rows where the displayed page price conflicts with the promo end date, or where official formulas contradict each other, are marked unconfirmed. They do not enter the “who is cheaper” ranking and are not included in monthly costs.
Video models at a glance
| Model | Comparison conditions | fal | Kinovi | Difference / notes |
|---|---|---|---|---|
| Seedance 2.5 | 480p, 16:9, text-to-video, no reference video | Approx. $0.2149/s Converted from tokens; the page also lists $0.2205/s | $0.1197/s | Kinovi −44.3% |
| Seedance 2.5 | 720p, 16:9, text-to-video, no reference video | Approx. $0.4622/s About $2.31 for 5 seconds; the page also lists $0.4730/s | $0.2717/s | Kinovi −41.2% |
| Seedance 2.5 Edit / Extend | 480p reference-tier unit price (the full job still has to be multiplied by billed seconds) | fal’s standalone edit-endpoint price is unconfirmed | $0.0737/s | Unconfirmed |
| Seedance 2.5 Flash | From 480p; displayed current price on the page | Not listed | From $0.0671/s | Kinovi only |
| Seedance 2.0 | 480p, text-to-video, no reference video | From approx. $0.1345/s | $0.0707/s | Kinovi −47.4% |
| Seedance 2.0 Fast | 720p can be aligned officially; Kinovi’s displayed price is unconfirmed | Approx. $0.2419/s | Displayed $0.0989/s Strikethrough $0.1319/s; promo end dates on the same page conflict | Unconfirmed |
| Seedance 2.0 Mini | 480p; Kinovi’s displayed price is unconfirmed | Approx. $0.0721/s | Displayed $0.0212/s Strikethrough $0.0353/s; promo end dates on the same page conflict | Unconfirmed |
| Kling 4.0 | 720p, text-to-video | $0.157/s | $0.1260/s List price $0.1504/s | Kinovi −19.7% (current price) |
| Wan 3.0 (text / image / reference) | 480p | $0.05/s | $0.0442/s List price $0.0663/s | Kinovi −11.6% (current price) |
| Wan 3.0 Prime | 480p | $0.068/s | $0.0658/s List price $0.0877/s | Kinovi −3.2% (current price) |
| MiniMax H3 (standard) | 768p | $0.06/s | $0.0677/s | Kinovi +12.8% |
| MiniMax H3 Max | 768p | $0.08/s | $0.0677/s | Kinovi −15.4% |
| MiniMax H3 Max Turbo | 768p | $0.04/s | $0.0352/s | Kinovi −12.0% |
| HappyHorse 1.0 / 1.1 | 720p; different versions, not the same model | $0.14/s (1.1) | $0.0801/s (1.0) | Kinovi −42.8% |
| Grok Imagine Video 1.5 | fal’s 480p can be aligned; Kinovi does not state a resolution | $0.08/s (480p) | $0.0501/s | About −37.4% when aligned at 480p; whether 720p/1080p share the same price is unconfirmed |
| Grok Imagine 1.5 Lite | — | Not offered | $0.0125/s | Kinovi only |
| Veo 3.1 Fast | 720p/1080p | $0.10/s without audio / $0.15/s with audio | Not offered | fal only |
| FLUX 3 Max | 720p, promotional price on the page | $0.085/s List price $0.17/s; the promo is written through November 21 | Not offered | fal only |
| PixVerse V6 | From 360p, no audio | From $0.025/s | Not offered | fal only |
| LTX 2.5 | 720p | $0.12/s | Not offered | fal only |
| Gemini Omni / Happy Oyster | — | No published uniform rate | Not offered | In the fal catalog only; no published unit price |
Official price lists: fal Seedance 2.5 · fal standard H3 · fal H3 Max · fal Seedance 2.0 Fast · fal Seedance 2.0 Mini.
Start with three groups of rows that can already be checked. For Seedance 2.5 at 16:9 with no reference video, Kinovi is about 40% lower; the 2.0 standard tier at 480p is about 47% lower. Kling 4.0 and Wan 3.0 need both current and list prices: current prices are about 12%–20% lower, Kling’s list price is only about 4% lower, and Wan’s list price is about 33% higher. MiniMax has to be compared at the same model and the same resolution: at 768p, standard H3 is about 13% more expensive on Kinovi; at 768p, H3 Max and Turbo are about 15% and 12% lower on Kinovi. The featured table on the fal pricing page still lists H3 Max at $0.03/s, which does not match the model page’s $0.05/$0.08/$0.16 from November 16 onward. This article follows the model page.
Seedance 2.0 Fast and Mini are separate endpoints on fal, so you cannot reuse the 2.0 standard-tier $0.1345/s. The corresponding Kinovi model pages show lower figures, but the same pages write the promo end date as both Oct 8 and Dec 8, so the amount actually paid cannot be treated as confirmed. This row lists the numbers only and does not enter the ranking.
Image models at a glance
| Model | Tier | fal | Kinovi | Difference / notes |
|---|---|---|---|---|
| Nano Banana Pro | 1K–2K | $0.15/image | $0.067/image | Kinovi −55.3% |
| Nano Banana Pro | 4K | $0.30/image The page states that 4K is twice the standard price; web search adds another $0.015 | $0.12/image | Kinovi −60.0% |
| Nano Banana 2 | 2K | $0.12/image Standard price $0.08; 2K is 1.5× | $0.0707/image | Kinovi −41.1% |
| Nano Banana 2 | 4K | $0.16/image 2× the standard price | $0.1178/image | Kinovi −26.4% |
| Nano Banana (previous generation) | Per image | $0.0398/image | Provided by Nano Banana Pro’s editing capability; no separately aligned quote | Not a direct conversion |
| GPT Image 2 | Different units; not directly comparable | $1/unit | Low·1K $0.0100/image through High·4K $0.7200/image | Different units; $0.0100 is only the lowest tier |
| GPT Image 2.5 | Per token | No uniform unit price found on fal’s price pages | $0.0054/1k tokens (Flare / Sunburst) | Unconfirmed on the fal side |
| Seedream 5.0 Pro | Per image | Not located on the fal endpoint page; Kinovi’s comparison column lists $0.0675/image | Page displays $0.0527/image strikethrough $0.0659/image; the promo end date is written as November 18, earlier than the price-check date, so the amount actually paid is unconfirmed | Unconfirmed |
| Seedream 5.5 | Per image | Not offered | $0.0180/image | Kinovi only |
| Qwen Image | Different versions | Image 3 is in the fal catalog; today’s price page has no uniform unit price | The Image 2.1 unit price in the original write-up was not found on today’s Kinovi pricing page | A missing quote, not “unsupported” |
| FLUX 2 / Ideogram / Krea / Reve / Sana | — | Today’s featured table on the fal pricing page has no complete, item-by-item unit prices that can be checked; see each endpoint page | Not offered | In the fal catalog only; unit prices were not confirmed in this table |
| Midjourney V8 / Niji V7 | 4 images | Not offered | $0.0565 / 4 images | Kinovi only |
| SeedVR2 upscale | — | Not offered | Findable on the model page; no published unit price | Kinovi only; quote missing |
Official price lists: fal Nano Banana Pro · fal Nano Banana 2 · Kinovi Nano Banana Pro · Kinovi Seedream 5.0 Pro.
The rows that align cleanly and have already been checked are the two Nano Banana generations. For Pro at 1K–2K and 4K, Kinovi is about 55% and 60% lower. Nano Banana 2 has to be compared at the same size: about 41% lower at 2K and about 26% lower at 4K. Don’t read GPT Image 2 as “$0.01 versus $1”: fal bills by unit, while Kinovi is tiered by quality and resolution, from Low·1K at $0.0100 to High·4K at $0.7200. Seedream 5.0 Pro’s discount end date is already earlier than the price-check day, so this row keeps the page figures only and does not conclude who is cheaper.


The Seedance family
fal’s Seedance 2.5 endpoint bills by output tokens: $0.0214 per thousand tokens at 480p and 720p, about $0.0234 at 1080p, and $0.0094 at 4K. The token count is (height × width × duration × 24) / 1024, and audio is produced in the same generation at no extra charge. Using the official 16:9 pixel dimensions, 5 seconds at 720p (1280×720) is 108,000 tokens, or about $2.31, about $0.4622 per second; 30 seconds is about $13.87. The same page also prints about $0.2205, $0.4730, $1.164, and $1.840 per second, slightly higher than the formula results. Later per-job and monthly figures all use the formula results, so the same model is not compared under different conventions in different tables.

Wider frames have more pixels, so each second costs more than a narrower frame.duration and aspect_ratio can default to auto, the model chooses the duration and frame itself, and the token count changes. To compare prices or build a budget, both of these need to be pinned.
Kinovi’s Seedance 2.5 is priced per second. With no reference video, 480p is $0.1197, 720p $0.2717, 1080p $0.6604, and 4K $1.0964, billed on output duration only. With a reference video, the unit price drops by about half ($0.1612/s at 720p), but billed seconds become reference duration plus output duration. A 720p job with 5 seconds of output plus a 5-second reference video is 10 × $0.1612 = $1.612, which is more expensive than the no-reference 5 × $0.2717 = $1.3585—not half off the full job.


Seedance 2.0, Fast, and Mini follow a different rule: with a reference video they only switch to that resolution’s reference-tier unit price, still billing on the output duration you chose, without adding the reference video’s seconds. Do not apply the 2.5 formula to 2.0. On fal’s 2.5 page, one place writes tokens as including input plus output duration, while another formula writes output duration only, so the fal cost of 5 seconds plus a 5-second reference cannot be confirmed from the public page alone. That cell is left blank in the table below.
| Kinovi model | Inputs and billing | Duration | 480p / 720p | 1080p / 4K |
|---|---|---|---|---|
| Seedance 2.5 | Text or keyframes; billed on output duration only | 4–30s | $0.1197 / $0.2717 | $0.6604 / $1.0964 |
| Seedance 2.5, with a reference video | Up to 10 reference video clips; billed on reference duration + output duration | 4–30s | $0.0737 / $0.1612 | $0.3947 / $0.6720 |
| Seedance 2.5 Edit | Existing footage + a prompt; with a reference video, billed on input + output | 4–30s | $0.0737 / $0.1612 | $0.3947 / $0.6720 |
| Seedance 2.5 Extend | A clip to continue; with a reference video, billed on input + output | 4–30s | $0.0737 / $0.1612 | $0.3947 / $0.6720 |
| Seedance 2.5 Flash | Up to 720p; with a reference video, billed on reference duration + output duration | — | $0.0671 / $0.1506 (displayed current price on the page) | No 1080p / 4K |
| Seedance 2.0 | Up to 9 images, 3 videos, and 3 audio clips; billed on output duration only | 4–15s | $0.0707 / $0.1884 | $0.4239 / $0.9420 |
| Seedance 2.0, with a reference video | Switches to the reference-tier unit price, but still bills on output duration only | 4–15s | $0.0895 / $0.2261 | $0.5087 / $1.1305 |
| Seedance 2.0 Fast | Fast tier, up to 720p; displayed price unconfirmed | — | Displayed from $0.0495 / $0.0989 | — |
| Seedance 2.0 Mini | Low-price tier, up to 720p; displayed price unconfirmed | — | Displayed from $0.0212 / $0.0565 | — |
The full-job comparison below uses one consistent setup: 5 seconds of output + a 5-second reference video, at the same resolution. Control rows with no reference video are multiplied by 5 seconds only, so you can see whether a “lower unit price” actually makes the full job more expensive.
| Condition | How billed seconds are counted | fal full job | Kinovi full job | Notes |
|---|---|---|---|---|
| Seedance 2.5, 720p, no reference | Both sides bill 5 seconds of output | Approx. $2.31 | $1.3585 | Kinovi −41.2% |
| Seedance 2.5, 720p, 5s + 5s reference | Kinovi: 10 × the reference-tier unit price; fal: the formulas conflict, no quote | Unconfirmed | $1.612 | Kinovi’s full job is higher than the no-reference $1.3585 |
| Seedance 2.5, 480p, no reference | 5 seconds of output | Approx. $1.0747 | $0.5985 | Kinovi −44.3% |
| Seedance 2.5, 480p, 5s + 5s reference | Kinovi: 10 seconds; fal: unconfirmed | Unconfirmed | $0.737 | Also higher than the no-reference $0.5985 |
| Seedance 2.0, 720p, no reference | 5 seconds of output | Approx. $1.517 | $0.942 | fal at the page rate of $0.3034/s |
| Seedance 2.0, 720p, 5s + 5s reference | Kinovi bills 5 seconds of output only, at the reference-tier $0.2261/s | fal’s reference-tier full job was not separately verified | $1.1305 | More expensive than no reference, but not multiplied by 10 seconds |
| Seedance 2.5 Flash, 720p, no reference | 5 seconds of output | Not listed | $0.753 | 5 × $0.1506, displayed current price on the page |
| Seedance 2.5 Flash, 720p, 5s + 5s reference | Kinovi: 10 × $0.0917 | Not listed | $0.917 | Higher than the no-reference $0.753 |
Official price lists: fal Seedance 2.5 formula and listed rates · Kinovi Seedance 2.5 price table and billing notes · Kinovi Seedance 2.0 billing notes.
For a 5-second 720p job with no reference, fal is about $2.31 and Kinovi is $1.3585, a gap of about 41%. After scaling 1080p and 4K with the same formula, the gap stays around 40%: about $1.1372/s versus $0.6604/s at 1080p (1920×1080), and about $1.8274/s versus $1.0964/s at 4K (3840×2160). Edit and extend jobs use the reference-tier unit price; if the reference video is as long as the output, Kinovi’s full job is not necessarily cheaper than generating from scratch. There is no checked standalone edit price on the fal side, so this article does not draw a comparison there.
Takeaway: When Seedance 2.5 includes a reference video, the unit price falls, but billed seconds become reference duration plus output duration, so the full job can cost more than one without a reference. 2.0, Fast, and Mini only switch to the reference-tier unit price and still bill on output duration. Do not apply the 2.5 formula to them.
fal also sells Seedance 1.0 Pro Fast, at $1 per million tokens, plus Seedance 2.0 reference / image-to-video billed at $0.014 per thousand tokens. These are different generations and should not be mixed into the table above. 2.0 Fast and Mini are also separate endpoints on fal: Fast is $0.0112 per thousand tokens, or about $0.2419/s at 720p; the Mini page lists about $0.0721/s at 480p and about $0.1547/s at 720p.


The Kling family
Both sides have Kling 4.0.fal’s Kling 4.0 is priced at 720p $0.157/s, 1080p $0.235/s, 4K $0.549/s, for durations of 3–30 seconds, defaulting to 1080p—if you omit the resolution, you are billed at the more expensive tier. Optional 10-bit HDR adds another $0.047/s at 1080p and $0.078/s at 4K.Kinovi’s Kling 4.0 list prices are $0.1504/s at 720p and $0.2256/s at 1080p, and the current discounted prices are $0.1260/s and $0.1890/s. 4K is not offered.
At list price, Kinovi is 4% cheaper at both resolutions, which is in the noise. At the current discounted price, the gap widens to about 20%—but that is a promotion, not a long-term price. fal still sells Kling v2.5 Turbo Pro at $0.07/s and v3 Pro at $0.14/s. Kinovi does not have these older tiers, and they remain useful if your prompts were tuned on that generation.
fal’s 4K tier has no Kinovi counterpart; if you need 4K Kling, you have to stay on fal. The default resolution on both sides is 1080p: fal bills at 1080p if you omit it, and Kinovi’s API default is also 1080p. If a draft only needs 720p, you must pass that in explicitly, or you will be billed at the more expensive tier. If Kling is your main model, the decision should turn on whether you need 4K, and on how long the roughly 20% current-price discount will last.
Official price lists: fal Kling 4.0 · Kinovi Kling 4.0 current and list prices.
The Wan family
fal tiers Wan 3.0 and Wan 3.0 Prime by resolution: Wan 3.0 is $0.05 at 480p, $0.10 at 720p, and $0.20 at 1080p per second; Prime is $0.068 / $0.14 / $0.28.Kinovi’s Wan 3.0 currently displays current prices of $0.0442 / $0.0884 / $0.1767, with strikethrough list prices of $0.0663 / $0.1326 / $0.2651; Prime current prices are $0.0658 / $0.1354 / $0.2709, and list prices are $0.0877 / $0.1806 / $0.3611. Image-to-video accepts one or two keyframes; reference-to-video accepts images, video, audio, web pages, and documents. This Kinovi family bills by output second.
At these displayed current prices, Kinovi is about 12% lower (about 3% for Prime); at the strikethrough list prices, every tier is about 33% higher. Promo end dates on the same page are not consistent. These current prices are the numbers the page showed at the time, and cannot be treated as a locked amount actually paid.
| Kinovi Wan 3.0 | Input | 480p current / list price | 720p current / list price | 1080p current / list price |
|---|---|---|---|---|
| Text-to-video | Text prompt | $0.0442 / $0.0663 | $0.0884 / $0.1326 | $0.1767 / $0.2651 |
| Image-to-video | 1–2 keyframes | $0.0442 / $0.0663 | $0.0884 / $0.1326 | $0.1767 / $0.2651 |
| Reference-to-video | Images, video, audio, web pages, and documents | $0.0442 / $0.0663 | $0.0884 / $0.1326 | $0.1767 / $0.2651 |
| Prime text-to-video | Text, faster inference | $0.0658 / $0.0877 | $0.1354 / $0.1806 | $0.2709 / $0.3611 |
| Prime image-to-video | 1–2 keyframes, faster inference | $0.0658 / $0.0877 | $0.1354 / $0.1806 | $0.2709 / $0.3611 |
Official price lists: fal Wan 3.0 · fal Wan 3.0 Prime · Kinovi Wan 3.0 current and list prices.

The MiniMax H3 family
Standard H3, H3 Max, and H3 Max Turbo are three product lines. Both fal and Kinovi have matching endpoints, and they have to be compared at the same model and the same resolution. The Max / Turbo figures in the featured table on the fal pricing page are still outdated; the prices below come from each model page.
| Tier | Resolution | fal | Kinovi | Difference |
|---|---|---|---|---|
| Standard H3 | 480p | $0.05/s | Not listed on this model page | — |
| Standard H3 | 768p | $0.06/s | $0.0677/s | Kinovi +12.8% |
| Standard H3 | 2K | $0.13/s | $0.1083/s | Kinovi −16.7% |
| Standard H3 | 4K | $0.16/s | Not listed on this model page | — |
| H3 Max | 480p | $0.05/s | $0.0447/s | Kinovi −10.6% |
| H3 Max | 768p | $0.08/s | $0.0677/s | Kinovi −15.4% |
| H3 Max | 1080p | $0.16/s | Not listed on this model page | — |
| H3 Max Turbo | 480p | $0.025/s | $0.0230/s | Kinovi −8.0% |
| H3 Max Turbo | 768p | $0.04/s | $0.0352/s | Kinovi −12.0% |
| H3 Max Turbo | 1080p | $0.08/s | Not listed on this model page | — |
Official price lists: fal standard H3 · fal H3 Max · fal H3 Max Turbo · Kinovi standard H3 · Kinovi H3 Max · Kinovi H3 Max Turbo.
Aligning Kinovi’s from-480p starting price with fal’s 768p would stretch the Max and Turbo gaps past forty percentage points. That comparison is not usable. Once they are aligned at 768p, the standard tier is lower on fal, and Max and Turbo are lower on Kinovi, by about 12%–15%.Kinovi standard H3 The model page states a duration of 4–15 seconds and accepts text prompts only.



Other video models
HappyHorse is available on both sides: fal’s 1.1 version is $0.14/s at 720p and $0.18/s at 1080p, and Kinovi’s 1.0 version is $0.0801/s, 43% cheaper—but the versions differ, so they cannot be treated as the same model.Grok Imagine Video 1.5 is listed on both sides: fal is $0.08 at 480p, $0.14 at 720p, and $0.25 at 1080p per second; the Kinovi pricing page lists $0.0501/s and does not state a resolution. Aligned with fal’s 480p $0.08/s, that is about 37% lower; whether 720p and 1080p are the same price is not settled on the public pages. The Lite tier is on Kinovi only ($0.0125/s).Veo 3.1 Fast is exclusive to fal, at $0.10/s (no audio) and $0.15/s (with audio) for 720p/1080p, and $0.30/$0.35 for 4K.
FLUX 3 Max is billed per second, currently promoted at $0.085/s with a list price of $0.17/s (ending November 21); PixVerse V6 is tiered at $0.025–$0.115/s (plus extra with audio); LTX 2.5 is $0.12/s at 720p and $0.17/s at 1080p. All three are exclusive to fal; Kinovi has no counterpart.Gemini Omni and Happy Oyster can be found in the fal catalog, but have no published uniform rate; this article does not give numbers. Conversely, Seedance 2.5 Flash, Seedream 5.5, Midjourney V8/Niji V7, SeedVR2 upscale, and Grok Lite are on Kinovi only—a structural difference.
Official price lists: fal FLUX 3 Max · fal Grok Imagine Video 1.5.
Coverage differences, in short
The rows that can be checked, with a stable gap, are Seedance 2.5 / 2.0 standard (no reference video) and the two Nano Banana generations, where Kinovi is about 40%–60% lower. Kling 4.0 is about 20% lower at the current price, and only about 4% lower at list price. Wan 3.0 is about 12% lower at the current price and about 33% higher at list price. Prime has the same structure: slightly lower at the current price, cheaper on fal at list price (list price $0.1806 versus $0.14 at 720p). MiniMax cannot be concluded as a group: at 768p, standard H3 is lower on fal, and at 768p, Max and Turbo are lower on Kinovi.
The 720p figures for HappyHorse differ by a lot, but one side is 1.1 and the other is 1.0, so they cannot be treated as the same model. Displayed Kinovi prices for Seedream 5.0 Pro and Seedance 2.0 Fast / Mini still cannot be confirmed, and they are not placed in the “clearly cheaper” column. Veo 3.1, FLUX 3 Max, PixVerse, LTX, and 4K Kling remain exclusive to fal, or only fal offers the matching tier.
Takeaway: The Seedance 2.5 and 2.0 standard tiers and Nano Banana rows already checked are often enough to decide whether to migrate one product line first. H3 has to be compared by specific model and resolution; Wan and Kling need both current and list prices in the math. Exclusive fal options such as Veo, FLUX, and 4K Kling are what decide whether you still need to keep a second platform.
Official price lists: fal model catalog.
### Audio and platform capabilitiesAudio is the category most often missed in a price comparison. Kinovi’s pricing page lists Suno Music, Sample, and Remix (16 credits/request) and Sounds (4 credits/request), plus Seed Audio 1.0 text-to-speech, speech-to-speech, image-to-speech, and sound effects, all at $0.0030/s. fal also lists audio endpoints such as Suno and Seed Audio, but rates are published per endpoint. The unit of value for these models is completely different from video—per request, per second, or per character—so they can only be aligned endpoint by endpoint, and cannot be mixed into the video tables.
| Category | Kinovi | fal | Conclusion |
|---|---|---|---|
| Music generation | Suno Music / Sample / Remix, 16 credits/request; Sounds, 4 credits/request | No published uniform rate | Compare endpoint by endpoint |
| Speech and sound effects | Four Seed Audio 1.0 types, $0.0030/s | No published uniform rate | Compare endpoint by endpoint |
| 3D | Not offered | Hunyuan 3D and others | fal only |
| Deploy your own models | Not offered | Serverless / Compute | fal only |
Once audio and 3D are included, what “full coverage” means becomes clear: Kinovi covers the mainstream generative-media video and image paths, plus a thin slice of audio; fal covers a wider catalog plus infrastructure. When you choose, first ask “how many classes of model does my product actually call,” then ask about price—for a team that only calls two classes of model, catalog breadth is a cost, not an asset.
A month of cost
All three workloads use the rates already checked above. Totals are calculated at the same model version and the same resolution; both sides of the Kling row are 4.0. The video jobs are all text-to-video, with no reference video, and duration and resolution are pinned. Kinovi’s Kling and Wan use the current prices displayed on the page; if list (strikethrough) prices are used instead, that is noted under each table.
Indie developers
50 5-second 720p jobs a month, of which 30 are Seedance 2.5 and 20 are Wan 3.0.
| Model | Monthly volume | fal | Kinovi (current price) | Difference |
|---|---|---|---|---|
| Seedance 2.5, 720p | 30 × 5s | $69.30 | $40.76 | −41.2% |
| Wan 3.0, 720p | 20 × 5s | $10.00 | $8.84 | −11.6% |
| Monthly total | 50 jobs | $79.30 | $49.60 | −37.5% |
At this volume, the month differs by about $30. The decision should turn more on how jobs are integrated, and on whether credits expire, than on unit price alone. If Wan is recalculated at the list price of $0.1326/s, the Kinovi row becomes $13.26 and the total $54.02, and Wan flips from cheaper to more expensive.
The conversion: 30 × $2.31 = $69.30 (fal, the 5-second 720p token example); 30 × 5s × $0.2717/s = $40.76 (Kinovi); 20 × 5s × $0.10/s = $10.00, versus 20 × 5s × $0.0884/s = $8.84.
High-volume SaaS products
2,000 10-second 1080p jobs a month: 1,000 Seedance 2.5, 600 Kling, and 400 Wan 3.0.
| Model | Monthly volume | fal | Kinovi (current price) | Difference |
|---|---|---|---|---|
| Seedance 2.5, 1080p | 1,000 × 10s | $11,372 | $6,604 | −41.9% |
| Kling 4.0, 1080p | 600 × 10s | $1,410 | $1,134 | −19.6% |
| Wan 3.0, 1080p | 400 × 10s | $800 | $706.80 | −11.6% |
| Monthly total | 2,000 jobs | $13,582 | $8,444.80 | −37.8% |
The total is about 38% lower, but the total is not the most useful number. The money is concentrated in Seedance; the current-price gaps for Kling and Wan are much smaller. Moving Seedance already captures most of the difference. If Kling and Wan are recalculated at list price, those two Kinovi rows become $1,354 and $1,060, and the total becomes $9,018.
Concurrency turns this into a scheduling problem. At about 75 seconds of wall-clock time per 10-second 1080p job, 2,000 jobs are about 42 hours of generation. That is about 21 hours at 2 concurrent slots, and about 1 hour at 40. fal’s 2 → 40 rise happens automatically with spend, so a first-day traffic spike still has to wait.
The conversion: 1,000 × 10s × $1.1372/s = $11,372 (fal, 1920×1080, $0.0234 per thousand tokens); 1,000 × 10s × $0.6604/s = $6,604; 600 × 10s × $0.235/s = $1,410; 600 × 10s × $0.1890/s = $1,134; 400 × 10s × $0.20/s = $800; 400 × 10s × $0.1767/s = $706.80.
Ad teams that iterate on cuts
300 8-second 720p jobs a month, plus 1,000 1K product images.
| Item | Monthly volume | fal | Kinovi | Difference |
|---|---|---|---|---|
| Seedance 2.5, 720p | 300 × 8s | $1,108.80 | $652 | −41.2% |
| Nano Banana Pro, 1K | 1,000 images | $150 | $67 | −55.3% |
| Monthly total | — | $1,258.80 | $719 | −42.9% |
Most of the gap comes from Seedance 2.5’s token unit price and Nano Banana Pro’s per-image price. Workloads like this are often edits of existing shots, not generation from scratch. Kinovi’s Seedance 2.5 Edit is $0.1612/s at 720p; if the reference video is also 8 seconds, billed seconds are input plus output, and the full job is 16 × $0.1612 = $2.5792, already higher than generating from scratch at 8 × $0.2717 = $2.1736. Whether editing is cheaper depends first on how long the reference video is; you cannot just look at a unit price that is half as high.
The conversion: 300 × 8/5 × $2.31 = $1,108.80 (the same convention as the 5-second example); 300 × 8s × $0.2717/s = $652.08; 1,000 × $0.15 = $150; 1,000 × $0.067 = $67.
Takeaway: All three monthly cost tables are calculated on text-to-video jobs with no reference video, and most of the gap comes from Seedance. At low volume, a month may differ by only a few tens of dollars, so integration cost and whether the balance expires matter more; once volume rises, moving the Seedance line first often captures most of the difference. If day-to-day work is editing existing shots, calculate the edit job separately against the reference video’s duration. Do not apply the from-scratch monthly totals directly.
Migrating the integration
Kinovi’s API has five routes: createTask, recordInfo, uploads, account and upgradeDraft, and every model shares the same envelope. fal’s queue protocol is also consistent—submit, poll, fetch the result—but the path and request body change by endpoint, so a client that supports five models has to maintain five adapters plus a queue client.
Endpoint and field mapping
| fal | Kinovi | Notes |
|---|---|---|
Authorization: Key $FAL_KEY | Authorization: Bearer $KINOVI_API_KEY | The header format differs; the idea is the same: one key per account. |
POST https://fal.run/<endpoint_id> | POST /api/v1/jobs/createTask | fal’s sync path has no Kinovi counterpart; every job is asynchronous. |
POST https://queue.fal.run/<endpoint_id> | POST /api/v1/jobs/createTask | Every model uses the same endpoint. |
| The endpoint id goes in the path | model field | To change models you change one string, not the URL. |
| A separate request body for each endpoint | inputs object | Field names vary by model on both sides; the envelope does not. |
request_id | taskId | Keep treating it as an idempotency key. |
GET {status_url} | GET /api/v1/jobs/recordInfo?taskId= | fal gives you a URL; on Kinovi you look the id up. |
IN_QUEUE / IN_PROGRESS / COMPLETED | waiting / generating / success | fail | Three states collapse into two terminal states. |
GET {response_url} | recordInfo → output[] | It is the same request as checking status. |
?fal_webhook= | in the request bodycallBackUrl | fal callback statuses are OK/ERROR; both sides need deduplication by id. |
PUT …/requests/{id}/cancel | No cancel route seen in the REST API | fal distinguishes cancel-while-queued from cancel-in-progress; confirm this before you depend on it. |
Automatic retries up to 10 times, plus X-Fal-No-Retry | No client retry switch | Retries happen on the platform side; the client still needs to be idempotent. |
queue_position | Exceeding concurrency returns HTTP 429 | Failure modes differ; 429s need explicit handling. |
| fal storage / File API | POST /api/v1/uploads | Upload first, then pass the public URL into imageUrls or videoUrls. |
GET /v1/models/pricing | No estimate in REST; MCP has one | Calculate the reservation from the public unit price yourself, then reconcile afterwards with creditsUsed. |
Two structural differences matter more than field names. Kinovi reserves credits at submit time and returns creditsUsed afterwards, so gross-margin math has to handle both the “reserved amount” and the “final amount.” fal deducts from the balance after the fact; the failure mode is a locked account, not a rejected reservation.
Official price lists: fal Queue API docs · Kinovi API reference.
Before the change: a fal queue client
// fal SDK: subscribe() wraps submit, polling, and fetching the result in a single call.
import { fal } from "@fal-ai/client";
fal.config({ credentials: process.env.FAL_KEY });
const { data, requestId } = await fal.subscribe("bytedance/seedance-2.5/text-to-video", {
input: {
prompt,
duration: "5", // A numeric value as a string; writing "auto" will change the token count.
resolution: "720p",
aspect_ratio: "16:9",
generate_audio: false,
},
logs: true,
});
console.log(requestId, data.video.url);
The same job, hitting the queue directly without an SDK:
// Raw queue call: you own the polling loop and the terminal-state check. const res = await fetch("https://queue.fal.run/bytedance/seedance-2.5/text-to-video", { method: "POST", headers: { Authorization: `Key ${process.env.FAL_KEY}`, "Content-Type": "application/json", }, body: JSON.stringify({ prompt, duration: "5", resolution: "720p" }), });const { request_id, status_url, response_url } = await res.json();
// Poll status until COMPLETED, then read the result URL. while (true) { const status = await fetch(status_url, { headers: { Authorization: falAuth } }).then((r) => r.json()); if (status.status === "COMPLETED") break; await new Promise((r) => setTimeout(r, 3000)); }
const result = await fetch(response_url, { headers: { Authorization: falAuth } }).then((r) => r.json());
After the change: the same job running on Kinovi
const KINOVI = "https://kinovi.ai/api/v1";
const auth = { Authorization: `Bearer ${process.env.KINOVI_API_KEY}` };
// Submit; every model shares the same createTask envelope.
const created = await fetch(`${KINOVI}/jobs/createTask`, {
method: "POST",
headers: { ...auth, "Content-Type": "application/json" },
body: JSON.stringify({
model: "seedance2-5",
inputs: {
prompt,
duration: 5,
outputResolution: "720p",
aspectRatio: "16:9",
},
callBackUrl: "https://your.app/hooks/kinovi",
}),
});
const { taskId } = await created.json();
// Poll recordInfo until the job reaches a terminal state.
let info;
for (let i = 0; i < 120; i += 1) {
const res = await fetch(`${KINOVI}/jobs/recordInfo?taskId=${taskId}`, { headers: auth });
if (res.status === 429) throw new Error("Concurrency exceeded");
info = await res.json();
if (info.status === "success" || info.status === "fail") break;
await new Promise((r) => setTimeout(r, 2000));
}
if (info.status === "fail") throw new Error(`${info.error.code}: ${info.error.message}`);
console.log(info.output[0].url, info.creditsUsed);
The same submit, as a single curl:
curl -X POST https://kinovi.ai/api/v1/jobs/createTask \
-H "Authorization: Bearer $KINOVI_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"seedance2-5","inputs":{"prompt":"Product turntable on white","duration":5,"outputResolution":"720p"}}'
It returns {"taskId":"task_..."}. Poll GET /api/v1/jobs/recordInfo?taskId=... until the status is success or fail. This is the same job as the fal example above: the same prompt, 5 seconds, 720p, 16:9, and no reference file. When you need a reference image or reference video, first call POST /api/v1/uploads, then pass the returned public URL into imageUrls or videoUrls. Once you add videoUrls, Seedance 2.5 switches to the reference tier and bills on reference duration plus output duration, which is no longer the price of this job.
// Kinovi webhook: acknowledge quickly, and keep the handler idempotent.
app.post("/hooks/kinovi", async (req, res) => {
res.sendStatus(200); // A non-2xx response triggers a retry.
const { taskId, status, output } = req.body;
if (seen.has(taskId)) return; // Same dedupe logic as the one you use for fal request_id.
seen.add(taskId);
if (status === "success") await store(taskId, output[0].url);
});
Takeaway: When accepting the integration, first run a job identical to the fal example: the same prompt, the same duration and resolution, and no reference file yet. After submit, poll with recordInfo, then reconcile the returned creditsUsed against the public unit price. Once a reference video is added, Seedance 2.5 switches to a different billing rule, and what you reconcile will not be the price of this job.
If you’d rather not write HTTP, Kinovi’s MCP server exposes the same set of models and the same balance to Claude Code, Claude Desktop, Cursor, Codex CLI, and ChatGPT, and it includes a cost-estimate tool that REST does not have.
Switching order:
- Migrate one model first, not the whole catalog. Seedance 2.5 is a good acceptance case: compare the cost calculated from the public formula or unit price with the amount actually deducted. Each side should come close to its own published price.
- Pin the version in config. fal’s endpoint id already carries a version, and so does Kinovi’s
modelfield; neither side should silently follow a default. - Keep your own request key.
request_idandtaskIdbelong only to their own platforms. Store the key you generate and map it. - Download into your own bucket inside the retention window. fal’s seven days and Kinovi’s thirty days are not storage.
- Confirm the concurrency tier before you migrate traffic. Kinovi’s tiers are assigned, not purchased, and new accounts start at 3.
Billing, refunds, and retention
| Item | fal | Kinovi |
|---|---|---|
| Billing unit | Prepaid credits, by endpoint: image, megapixel, second, token, request, or GPU-second | Prepaid credits by model and resolution; published USD prices are on each model page |
| Expiration | Purchased credits expire 365 days from purchase; promotional credits commonly last 90 days | Credits do not expire |
| Account lock | There is a lock threshold; below it, requests are rejected | Judged from the balance; no lock threshold seen |
| Server-side failure | 5xx is not billed; queue time and cold starts are not billed; 422 may still be billed if the GPU already ran | Upstream failures, timeouts, and cancellations are refunded from the reserved credits |
| Output retention | At least 7 days by default, adjustable via request headers or account policy | 30 days |
| URL access | Public by default; ACL and lifecycle are controlled with request headers | CDN URL, served from the account’s media domain |
| Concurrency | New accounts start at 2 and rise automatically to 40 with spend; go higher through sales | 3 / 10 / 20 / 50 / 150–500, assigned |
| Pricing / estimate API | Yes, /v1/models/pricing | None in REST; MCP has an estimate tool |
| Usage detail | The Platform API covers billing, logs, files, and metrics | Console job history, plus each record’s creditsUsed |
The split that actually matters is “expiration” versus “observability.” fal gives better cost telemetry and locks the account when the balance runs out; Kinovi gives a balance that does not expire and a creditsUsed. Neither is strictly better, but for products with irregular usage, expiration is the more expensive way to fail.
Two refund boundaries are worth testing first. On fal, a 422 that returns only after the job has started counts as a billable client error, so a malformed request can still cost money; validate before you submit. On Kinovi, the reservation happens at submit time and is reconciled when the job ends, and a fail should return the reserved credits—when reconciling in bulk, look at the records, not just the total balance.
Official price lists: Kinovi credits and billing (concurrency tiers).
When you should stay on fal
If you want to deploy or fine-tune your own models, stay. Serverless and Compute are a different category from a hosted catalog. They are priced per GPU-second and cover B300, GB200, B200, H200, H100, and RTX PRO 6000. Kinovi has no substitute here.
If the product needs realtime or streaming inference, 3D output, or must use fal-exclusive models or exclusive tiers such as Veo 3.1 Fast, FLUX 3 Max, PixVerse V6, or 4K Kling, stay. These are not problems that a rate negotiation can fix.
Grok Imagine Video 1.5 is on both sides. The Kinovi pricing page lists $0.0501/s, while fal bills by resolution; before you move the whole group, confirm whether Kinovi is still that price at 720p and 1080p.
If finance or the platform team needs to integrate pricing, usage, and logs APIs, stay. Rebuilding that telemetry on top of a credits balance often costs more time than the migration would save.
If Wan 3.0 is a large share of the bill, run the numbers at both the current price and the list price. Today’s current price is about 12% lower; once it returns to list price, 1080p is $0.2651 versus $0.20, or about 33% more expensive. While the discount is still in place, this row does not have to default to staying on fal just because “the list price is higher.”
You can also stay if the load is small, the balance will be used up within a year, and the integration is already stable. In the fifty-jobs-a-month example above, the current prices differ by about $30. Rewriting a working client is usually not worth it for that amount.
If you do split, route by model, not by customer. Seedance 2.5, Seedance 2.5 Edit, and the already-checked still-image models can go on Kinovi; FLUX, Veo, 4K Kling, and realtime stay on fal. Decide Wan based on whether you accept the list price after the discount ends. Record on one internal job table, on both sides, which platform handled each id.
Other alternatives worth knowing
| Platform | Strengths | When to choose it | For Kinovi, this means |
|---|---|---|---|
| Replicate | Breadth of open-source models and community versions | You need an obscure open-source weight | Weaker on leading video models |
| RunPod | Bare GPUs and self-hosted inference | You are prepared to operate models yourself | Not an API product |
| WaveSpeed | Low reseller prices and support for sync mode | Price is the only consideration | Similar catalogs, different billing |
| Higgsfield | First-party tools (Genjutsu, Soul, Marketing Studio) | You need motion transfer or character tools | A narrower catalog and higher rates |
| Direct from the vendor | First-party access and roadmap | You only use one vendor’s models | One contract per vendor |
Who Kinovi is for
Kinovi is a fit for teams that generate across multiple model families, and want one integration, one balance, and credits that do not expire. Examples include developers shipping a video feature on Seedance 2.5 plus Nano Banana, and SaaS products that want Studio and the API to share one wallet. Ad or ecommerce teams that want to edit existing assets at the edit price need to calculate the full job against the reference video’s duration first, and not just look at a unit price that is half as high.
If you need to host your own models, need realtime or 3D, or must use FLUX 3 Max, Veo, or 4K Kling, it is not a complete replacement. Whether Wan 3.0 is a fit depends on whether you budget at the current price or the list price. The more common approach is to use both platforms and split traffic by model.
FAQ
Can the output be used commercially?
Yes, on both sides. Most of fal’s partner models are marked as commercially usable; you still need to read the terms for a given endpoint, and a few upstream vendors attach extra restrictions.
### Is there a free trial?fal’s complimentary free credits usually expire within 90 days, and paid credits expire after 365 days. Kinovi has no standing free allowance; new accounts may receive a small starter credit by region. Kinovi’s paid credits do not expire, so credits you have already evaluated and spent will not go unused because they lapsed.
### Do prices change?They will, on both sides, because the upstream is changing. fal moves endpoints between generations, and rates change with them; Kinovi locks the price at submit time, and a running job is not repriced. The figures in this article were checked on November 20, 2026.
### Which SDKs are supported?fal provides Python and JavaScript clients, plus REST. Kinovi is primarily REST, with an OpenAPI description at /openapi.json, plus an MCP server for agent clients. Any HTTP client works on either side.
### What happens if a generation fails?fal does not bill for 5xx or queue time, and failed requests are retried up to ten times; if the GPU already ran, a 422 may still be billed. Kinovi refunds upstream failures, timeouts, and cancellations from the reserved credits. If the result succeeds but you are unhappy with it, both sides charge.
### Will my data be used for training?Kinovi’s retention policy states that prompts, uploads, and results are not used to train models, except for models marked as training-data models. fal provides data-retention and lifecycle controls at the account and request level; check them against your own compliance requirements.
### Can fal code be migrated as-is?The queue mechanics map cleanly: request_id becomes taskId, status_url becomes recordInfo, fal_webhook becomes callBackUrl. The submit body does not, because fal’s fields are defined per endpoint. Remap the endpoint id, auth header, input fields, and billing unit model by model, then verify one job against the public rate, and only then migrate that model’s traffic.
Yes. fal’s Seedance 2.5 bills at $0.0214 per thousand tokens for 480p/720p, or about $2.31 for a 5-second 16:9 720p job; Kling 4.0 is $0.157/s (720p), $0.235/s (1080p), and $0.549/s (4K). Kinovi has both models. Seedance 2.5 is about 40% lower at the same resolution with no reference video; Kling 4.0 is about 20% lower at the current price, and about 4% lower at list price.
Get started
- Create a Kinovi account and generate a key under Account → API keys.
- Use the curl above to call seedance2-5, and run a 5-second 720p job with a one-sentence prompt. Don’t add a reference video yet.
- Poll recordInfo, download the outputs, and reconcile creditsUsed against the public unit price.
Model pages, parameters, and unit prices are at kinovi.ai/models; API details are at kinovi.ai/docs, and MCP setup is at kinovi.ai/docs/mcp.
Prices were checked on 2026-11-20. fal’s token-billed endpoints are converted with the formula published on the page and 16:9 pixel dimensions; if the page’s listed per-second rate disagrees with the formula, the comparison follows the formula. Kinovi’s USD prices come from the published figures on each model page. Monthly costs use the displayed current prices for Kling and Wan; Wan’s displayed current price cannot be treated as a locked amount actually paid. Rows marked unconfirmed were not included in the totals.
Official price lists: Kinovi API reference: base URL and Bearer auth.
Sources and editorial notes
Prices were checked on November 20, 2026, in US dollars, and do not include taxes, retry costs, or account discounts. Token conversions are marked “approx.” Kinovi shows both discounted current prices and strikethrough list prices for Wan and Kling; the summary tables and monthly costs in the body use the displayed current prices at the time, and also state the list prices. Promo end dates on the same Wan 3.0 page are not consistent, so the displayed current price cannot be treated as a locked amount actually paid. Rows such as Seedance 2.0 Fast / Mini and Seedream 5.0 Pro, where the displayed page price conflicts with the promo end date or the date has already passed, are marked unconfirmed. They do not support a firm cheaper-or-not conclusion, and they are not included in monthly costs.
fal pricing page · fal Seedance 2.5 · fal Seedance 2.0 · fal Seedance 2.0 Fast · fal Seedance 2.0 Mini · fal Kling 4.0 · fal Wan 3.0 · fal Wan 3.0 Prime · fal standard H3 · fal H3 Max · fal H3 Max Turbo · fal Queue API · Kinovi pricing · Kinovi Seedance 2.5 · Kinovi Seedance 2.0 · Kinovi Seedance 2.0 Fast · Kinovi Seedance 2.0 Mini · Kinovi Kling 4.0 · Kinovi Wan 3.0 · Kinovi MiniMax H3 · Kinovi H3 Max · Kinovi Nano Banana Pro · Kinovi billing · Kinovi API
Related articles
More to try
Related models

ByteDance · video model
Seedance 2.5
Seedance 2.5 is ByteDance’s next-generation AI video model for up to 30-second generation, multimodal references, and precise local editing.
$0.1197/s

ByteDance · video model
Seedance 2.0
Next-generation AI video model by ByteDance. Combines Fast and Pro modes for high-quality video generation.
$0.0707/s

Alibaba · video model
HappyHorse 1.0
HappyHorse 1.0 is Alibaba's high-quality video generation model on Kinovi, supporting text-to-video, image-to-video, reference-image video, and video editing modes.
$0.0801/s


