WaveSpeed API Alternative (2026): Pricing vs Kinovi & Migration Guide
Compare WaveSpeed API vs Kinovi (Nov 2026): 5%–54% lower rates on Seedance 2.5/2.0/Flash, Kling 4.0, MiniMax H3 & Nano Banana 2, plus cURL/TS/Python migration.

On this page
- WaveSpeed API vs Kinovi API at a Glance
- What Is the WaveSpeed API?
- Why Developers Look for a WaveSpeed API Alternative
- WaveSpeed API Pricing vs Kinovi: Model-by-Model Comparison
- Real Monthly Cost Scenarios: WaveSpeed API vs Kinovi
- Developer Migration Guide: Moving from WaveSpeed API to Kinovi
- Billing, Refunds, and Production Limits
- When You Should Stay on WaveSpeed (or Run Both)
- Other WaveSpeed API Alternatives Worth Comparing
- Who Kinovi Is Built For
- Frequently Asked Questions
- Get Started with the Kinovi API
If you already send production jobs to the WaveSpeed API, the fastest way to evaluate a WaveSpeed API alternative is to compare one exact request—same model version, resolution, duration, and reference-video billing rule. Across overlapping models audited on 20 November 2026, Kinovi prices Seedance 2.5, Seedance 2.0, Seedance 2.0 Fast, Seedance 2.5 Flash, Kling 4.0, MiniMax H3, and Nano Banana 2 (2K/4K) 5.6% to 53.8% lower than published WaveSpeed API pricing (and 19.7% to 53.8% lower vs WaveSpeed list rates), while consolidating every AI video generation API and image model behind one unified createTask / recordInfo REST contract and 30-day output retention.
As a broader WaveSpeed alternative, WaveSpeedAI still wins when you need its wider catalog (Veo, Luma, Meshy 3D, upscalers, LLM routes), official Python/JavaScript SDKs, signed webhook retries, or automatic Silver/Gold/Ultra concurrency tiers after a top-up. Many engineering teams keep WaveSpeed for catalog breadth and route high-volume Seedance, Kling 4.0, MiniMax H3, and Nano Banana 2 traffic to Kinovi.
Quick verdict (audited 2026-11-20): Compare exact per-job totals below before switching your WaveSpeed API key. Every rate in this guide is verified from official self-serve model pages, showing both WaveSpeed's list rate and its lower on-page promotional rate side by side.
WaveSpeed API vs Kinovi API at a Glance
| Dimension / Benchmark Job | WaveSpeed API (List / Page Rate) | Kinovi API | Difference / Winner |
|---|---|---|---|
| Seedance 2.5 (5s, 720p, no ref) | $1.80 / $1.62 | $1.3585 | 24.5% / 16.1% lower on Kinovi |
| Seedance 2.0 (5s, 720p, no ref) | $1.20 / $1.08 | $0.9420 | 21.5% / 12.8% lower on Kinovi |
| Seedance 2.0 Fast (5s, 720p, no ref) | $1.00 / $0.90 | $0.4945 | 50.6% / 45.1% lower on Kinovi |
| Seedance 2.5 Flash (5s, 720p, no ref) | $1.20 / $1.08 | $0.7530 | 37.3% / 30.3% lower on Kinovi |
| MiniMax H3 (5s, 768p T2V) | $0.50 | $0.3385 | 32.3% lower on Kinovi |
| Kling 4.0 (5s, 720p T2V) | $0.785 / $0.66725 | $0.6300 | 19.7% / 5.6% lower on Kinovi |
| Nano Banana 2 (2K T2I, no search) | $0.105 / $0.0945 | $0.0707 | 32.7% / 25.2% lower on Kinovi |
| API contract | Per-model path POST /api/v3/{model_id} | Unified POST /api/v1/jobs/createTask + model | One wrapper across models on Kinovi |
| Official SDKs & Sync mode | Python & JS/TS SDKs, sync mode, estimate API | cURL, Python & TS docs + hosted MCP | WaveSpeed |
| Webhooks | Signed (standard_webhook), up to 3 retries | Single callBackUrl POST (no retries) | WaveSpeed |
| Output file retention | ~7 days | 30 days | Kinovi (4.3× longer) |
| New-account concurrency | Bronze: 2 concurrent (Silver: 300 after top-up) | 3 concurrent (higher tiers on request) | WaveSpeed for instant self-serve scale |
Looking for a broader market overview beyond developer API migration? See our companion guide on the best WaveSpeedAI alternatives for AI video.
What Is the WaveSpeed API?
WaveSpeedAI is a prepaid, usage-based AI video generation API and multi-modal inference platform covering image, video, and audio models, with a wider catalog that also spans 3D generation, upscalers, and LLM endpoints. Clients authenticate with a WaveSpeed API key (Authorization: Bearer) and submit JSON to https://api.wavespeed.ai/api/v3/{model_id}, where model_id is the full path listed on each WaveSpeed model page—for example, bytedance/seedance-2.5/text-to-video. A successful submit returns a prediction id, and your backend polls GET /api/v3/predictions/{id}/result until the status reaches completed, failed, timeout, or cancelled.
Each WaveSpeed model page doubles as an interactive playground with a live price estimate on the Generate button plus cURL, Python, and JavaScript snippets. WaveSpeed also maintains official Python and JavaScript/TypeScript SDKs, a pricing estimate endpoint, sync mode, media uploads, and a hosted MCP server.
One nuance catches teams off guard when budgeting: "From $x / run" on a family card is a floor price, not the bill for a 10-second 1080p clip. Several WaveSpeed pages print two numbers in the same table cell. On Seedance 2.5 text-to-video, a 5-second 720p job shows $1.80 and $1.62, with the Generate button labeling the lower figure 10% OFF (Seedance 2.0 and Flash follow the same 10% spread). Kling 4.0 prints $0.157/s and $0.13345/s at 720p—a 15% gap with no promotion label on the table. Both numbers are reported in every comparison below so you never confuse a temporary discount with a permanent list rate.
Credits on WaveSpeed are prepaid via top-up. WaveSpeed's pricing and refund documentation states that balances never expire, failed requests and server-side timeouts are reversed automatically, purchased credits cannot be cashed out, and playground plus API predictions share the same history.
Why Developers Look for a WaveSpeed API Alternative
Fifty 5-second Seedance 2.5 clips at 720p is a modest prototype run; two thousand 10-second clips at the same resolution is a recurring infrastructure line item. Teams typically evaluate a WaveSpeed API alternative for four concrete engineering reasons:
- Per-second unit cost on high-volume video models: When Seedance 2.5, Seedance 2.0 Fast, or MiniMax H3 dominates your monthly spend, a 16%–50% unit-rate gap compounds into thousands of dollars per month.
- Endpoint & schema sprawl across models: WaveSpeed keeps one Bearer auth style and one poll URL, but every model has its own URL path and top-level JSON schema. Kinovi routes every model through
POST /api/v1/jobs/createTaskandGET /api/v1/jobs/recordInfo?taskId=..., swapping onlymodelandinputs. - Output URL retention windows: WaveSpeed generally expires generated media in 7 days, whereas Kinovi retains generated media for 30 days—reducing urgency for downstream download workers.
- Shared Studio + API prototyping balance: On Kinovi, prompt iteration in Studio and production backend jobs draw from the same non-expiring credit balance.
Takeaway: Moving off WaveSpeed only makes sense when the exact model, resolution, and reference-video billing rule actually lowers your bill or simplifies your wrapper—without breaking dependencies on WaveSpeed-only models, official SDKs, signed webhook retries, or Silver/Gold/Ultra concurrency tiers.
WaveSpeed API Pricing vs Kinovi: Model-by-Model Comparison
All tables below use official self-serve rates verified on 20 November 2026 from each platform's live model pages. Jobs are text-to-video or text-to-image with no reference video unless explicitly labeled. For Seedance reference-video rows, the benchmark job is identical across every table: 5 seconds of generated output + 5 seconds of reference video at the stated resolution. Billed seconds follow each platform's published formula (which is not always 10 seconds), documented directly above each table. Because public tables do not publish a separate surcharge for generate_audio, audio toggling is excluded from the delta math. Percentage savings are calculated as (WaveSpeed − Kinovi) / WaveSpeed; positive percentages mean Kinovi is cheaper.
Seedance 2.5 API Pricing (No Reference vs With Reference Video)
Seedance 2.5 on Kinovi (seedance2-5) and WaveSpeed's Seedance 2.5 endpoint both generate 4–30 second clips at 480p, 720p, 1080p, or 4K with optional image, video, and audio references. Without a reference video, both platforms bill strictly on output seconds. For a broader look at Seedance 2.5 providers, see How to Choose a Seedance 2.5 API.
Five-second Seedance 2.5 jobs, no reference video (sources: WaveSpeed, Kinovi Pricing):
| Resolution | WaveSpeed List | WaveSpeed Page Rate | Kinovi | vs List | vs Page Rate |
|---|---|---|---|---|---|
| 480p | $0.90 | $0.81 | $0.5985 | 33.5% lower | 26.1% lower |
| 720p | $1.80 | $1.62 | $1.3585 | 24.5% lower | 16.1% lower |
| 1080p | $4.50 | $4.05 | $3.3020 | 26.6% lower | 18.5% lower |
| 4K | $9.00 | $8.10 | $5.4820 | 39.1% lower | 32.3% lower |
At 720p, the 5-second math is 5 × $0.2717 on Kinovi vs 5 × $0.36 list and 5 × $0.324 page rate on WaveSpeed. Ten-second jobs scale linearly: $2.717 (Kinovi), $3.60 (WaveSpeed list), and $3.24 (WaveSpeed page rate).
Five-second output + 5-second reference video (Seedance 2.5): Both platforms bill this job on 10 total seconds. Kinovi charges (5 + 5) × its + reference video per-second rate (adding reference length up to 30 seconds at settlement). WaveSpeed charges (normalized reference duration + output duration) at its with-reference rate, normalizing each reference clip to a 2-second minimum, capping combined input at 30 seconds, and rounding up to whole seconds. At 720p, that is 10 × $0.1612 on Kinovi vs 10 × $0.22 list and 10 × $0.198 page rate on WaveSpeed.
| Resolution | WaveSpeed List | WaveSpeed Page Rate | Kinovi | vs List | vs Page Rate |
|---|---|---|---|---|---|
| 480p | $1.10 | $0.99 | $0.7370 | 33.0% lower | 25.6% lower |
| 720p | $2.20 | $1.98 | $1.6120 | 26.7% lower | 18.6% lower |
| 1080p | $5.50 | $4.95 | $3.9470 | 28.2% lower | 20.3% lower |
| 4K | $11.00 | $9.90 | $6.7200 | 38.9% lower | 32.1% lower |
Notice that although the per-second reference rate is lower than the no-reference rate, the 5 + 5 job ($1.6120 at 720p) still costs more than a 5-second no-reference clip ($1.3585) because the 5 reference seconds are billed too. Edit and extend modes on Kinovi (seedance2-5-edit, seedance2-5-extend) follow this same reference-video rate family; match them to WaveSpeed's video-edit and video-extend paths before migrating.
Seedance 2.0, Fast, and Seedance 2.5 Flash Pricing
Seedance 2.0 on Kinovi (seedance-20) and WaveSpeed's Seedance 2.0 endpoint both cap clips at 15 seconds and support up to 4K. WaveSpeed's default 5-second 720p clip is $1.20 list and $1.08 on-page (the same 10% spread). See also our Seedance 2.0 API pricing breakdown and best Seedance 2.0 API providers.
Five-second Seedance 2.0 jobs, no reference video (sources: WaveSpeed, Kinovi Pricing):
| Resolution | WaveSpeed List | WaveSpeed Page Rate | Kinovi | vs List | vs Page Rate |
|---|---|---|---|---|---|
| 480p | $0.60 | $0.54 | $0.3535 | 41.1% lower | 34.5% lower |
| 720p | $1.20 | $1.08 | $0.9420 | 21.5% lower | 12.8% lower |
| 1080p | $3.00 | $2.70 | $2.1195 | 29.4% lower | 21.5% lower |
| 4K | $6.00 | $5.40 | $4.7100 | 21.5% lower | 12.8% lower |
Five-second output + 5-second reference video (Seedance 2.0): Here the billed-seconds rule diverges. Kinovi switches to its + reference video per-second rate and bills at submit strictly on the output duration (5 × $0.2261 = $1.1305 at 720p, with no settlement surcharge). WaveSpeed bills (normalized reference duration + output duration) = 10 seconds (2-second minimum per clip, 15-second combined input cap, rounded up to whole seconds: 10 × $0.15 list or 10 × $0.135 page rate at 720p).
| Resolution | WaveSpeed List | WaveSpeed Page Rate | Kinovi | vs List | vs Page Rate |
|---|---|---|---|---|---|
| 480p | $0.75 | $0.675 | $0.4475 | 40.3% lower | 33.7% lower |
| 720p | $1.50 | $1.35 | $1.1305 | 24.6% lower | 16.3% lower |
| 1080p | $3.75 | $3.375 | $2.5435 | 32.2% lower | 24.6% lower |
| 4K | $7.50 | $6.75 | $5.6525 | 24.6% lower | 16.3% lower |
Seedance 2.0 Fast (seedance2-fast): Kinovi's draft route covers 480p and 720p (native 1080p stays on seedance-20). WaveSpeed Fast also lists 1080p and 4K, which have no Kinovi Fast equivalent and are excluded below.
Five-second Fast jobs, no reference video (480p and 720p):
| Resolution | WaveSpeed List | WaveSpeed Page Rate | Kinovi Fast | vs List | vs Page Rate |
|---|---|---|---|---|---|
| 480p | $0.50 | $0.45 | $0.2475 | 50.5% lower | 45.0% lower |
| 720p | $1.00 | $0.90 | $0.4945 | 50.6% lower | 45.1% lower |
Five-second output + 5-second reference video on Seedance 2.0 Fast (Kinovi bills 5 × $0.1201 at 720p; WaveSpeed bills 10 × $0.13 list / 10 × $0.117 page rate):
| Resolution | WaveSpeed List | WaveSpeed Page Rate | Kinovi Fast | vs List | vs Page Rate |
|---|---|---|---|---|---|
| 480p | $0.65 | $0.585 | $0.3180 | 51.1% lower | 45.6% lower |
| 720p | $1.30 | $1.17 | $0.6005 | 53.8% lower | 48.7% lower |
Seedance 2.5 Flash (seedance2-5-flash): Kinovi Flash supports 480p and 720p (4–30 seconds). WaveSpeed Flash lists 1080p and 4K as 720p generations that are upscaled afterward, so the apples-to-apples comparison stays at 480p and 720p. With no reference video, a 5-second 720p Flash clip is $0.7530 on Kinovi (5 × $0.1506) versus $1.20 list and $1.08 page rate on WaveSpeed (37.3% and 30.3% lower). At 480p, a 5-second clip is $0.3353 (5 × $0.0671).
Five-second output + 5-second reference video on Seedance 2.5 Flash (both platforms bill 10 seconds: 10 × $0.0917 at 720p on Kinovi vs 10 × $0.15 list and 10 × $0.135 page rate on WaveSpeed):
| Resolution | WaveSpeed List | WaveSpeed Page Rate | Kinovi Flash | vs List | vs Page Rate |
|---|---|---|---|---|---|
| 480p | $0.75 | $0.675 | $0.4090 | 45.5% lower | 39.4% lower |
| 720p | $1.50 | $1.35 | $0.9171 | 38.9% lower | 32.1% lower |
Note: Seedance 2.0 Mini is omitted because WaveSpeed has no same-named Mini endpoint (Fast Turbo is not treated as an equivalent).
Takeaway: If your workflow can run at 480p or 720p, Seedance 2.0 Fast ($0.4945 for 5s 720p) and Seedance 2.5 Flash ($0.7530) dramatically reduce spend compared to Seedance 2.5 ($1.3585 at 720p, $3.3020 at 1080p, $5.4820 at 4K).
MiniMax H3 and Kling 4.0 API Pricing
MiniMax H3 text-to-video on Kinovi (minimax-h3-text-to-video) and WaveSpeed's minimax/h3/text-to-video both accept a prompt, 4–15 second duration, and 768p or 2K output. WaveSpeed publishes one rate column ($0.10/s at 768p, $0.14/s at 2K); Kinovi lists $0.0677/s and $0.1083/s. (WaveSpeed's open-weights wavespeed-ai/minimax-h3 is a separate endpoint and excluded.) For full billing mechanics, see How MiniMax H3 Video Is Billed on Kinovi.
Five-second MiniMax H3 text-to-video jobs (sources: WaveSpeed, Kinovi Pricing):
| Resolution | WaveSpeed | Kinovi | vs WaveSpeed |
|---|---|---|---|
| 768p | $0.50 | $0.3385 | 32.3% lower |
| 2K | $0.70 | $0.5415 | 22.6% lower |
Kling 4.0 text-to-video: WaveSpeed's Kling 4.0 page lists 720p and 1080p (3–30s) at $0.157/s and $0.235/s list, or $0.13345/s and $0.19975/s as the lower on-page figure ($0.785 or $0.66725 for 5s at 720p; $1.175 or $0.99875 for 5s at 1080p). Kinovi's Kling 4.0 text-to-video (kling-4.0/text-to-video) prices 720p at $0.1260/s ($0.6300 for 5s) and 1080p at $0.1890/s ($0.9450 for 5s)—19.7% below WaveSpeed's list rate and 5.6% below WaveSpeed's lower on-page rate at 720p (19.6% / 5.4% lower at 1080p). Always match Kling 3.x, O3, and motion-control endpoints by exact version on the Kinovi Kling 4.0 pricing tab.
Image Models and Catalog Coverage Gaps
Nano Banana 2 on Kinovi (nanobanana2) and WaveSpeed's Nano Banana 2 text-to-image are compared per image with WaveSpeed search add-ons disabled (enable_web_search and enable_image_search set to false). Kinovi publishes 2K and 4K only.
Nano Banana 2 per-image pricing (sources: WaveSpeed, Kinovi Pricing):
| Resolution | WaveSpeed List | WaveSpeed Page Rate | Kinovi | vs List | vs Page Rate |
|---|---|---|---|---|---|
| 0.5K | $0.045 | $0.0405 | No public 0.5K row | — | — |
| 1K | $0.070 | $0.0630 | No public 1K row | — | — |
| 2K | $0.105 | $0.0945 | $0.0707 | 32.7% lower | 25.2% lower |
| 4K | $0.140 | $0.1260 | $0.1178 | 15.9% lower | 6.5% lower |
Seedream version-by-version: Both platforms publish Seedream 5.5 and Seedream 5.0 Pro (WaveSpeed uses seedream-v5.0-pro). WaveSpeed also publishes Seedream 4.5 ($0.04/image); Kinovi does not. Neither platform lists a 4K row on these pages.
Seedream 5.5 per-image pricing (sources: WaveSpeed, Kinovi Pricing):
| Resolution | WaveSpeed List | WaveSpeed Page Rate | Kinovi | vs List | vs Page Rate |
|---|---|---|---|---|---|
| 1K | $0.020 | $0.01900 | $0.0180 | 10.0% lower | 5.3% lower |
| 1.5K | $0.020 | $0.01900 | $0.0180 | 10.0% lower | 5.3% lower |
| 2K | $0.035 | $0.03325 | $0.0315 | 10.0% lower | 5.3% lower |
| 4K | No 4K row | No 4K row | No 4K row | — | — |
Seedream 5.0 Pro per-image pricing (sources: WaveSpeed, Kinovi Pricing):
| Resolution | WaveSpeed List | WaveSpeed Page Rate | Kinovi | vs List | vs Page Rate |
|---|---|---|---|---|---|
| 1K | $0.045 | $0.0405 | $0.0527 | 17.1% higher | 30.1% higher |
| 1.5K | $0.045 | $0.0405 | No public 1.5K row | — | — |
| 2K | $0.090 | $0.0810 | $0.0904 | 0.4% higher | 11.6% higher |
| 4K | No 4K row | No 4K row | No 4K row | — | — |
Seedream 4.5: Published only on WaveSpeed at $0.04 per generated image (not published on Kinovi).
Beyond these overlaps, WaveSpeed's catalog is significantly broader: Veo, Luma, Topaz and other upscalers, Meshy 3D, LLM routes, Cinema Studio, and a desktop app. If your product relies on those models, keep them on WaveSpeed and route only the overlapping models that price or integrate better.
Real Monthly Cost Scenarios: WaveSpeed API vs Kinovi
These monthly budgets apply the exact Seedance 2.5 and Nano Banana 2 rates from above (pure generation spend, excluding checkout taxes or credit bundle minimums).
Scenario A: 50 Five-Second 720p Videos / Month (Prototype / Indie App)
Seedance 2.5, no reference video, published per-second rate:
| Provider | Cost per Clip | Monthly Cost | Savings with Kinovi |
|---|---|---|---|
| WaveSpeed list | $1.80 | $90.00 | — |
| WaveSpeed page rate | $1.62 | $81.00 | — |
| Kinovi | $1.3585 | $67.93 | $22.08 below list / $13.08 below page rate |
Scenario B: 2,000 Ten-Second 720p Videos / Month (Production SaaS)
Same model, resolution, and billing rule. Both platforms scale linearly with duration ($2.717 on Kinovi vs $3.60 list and $3.24 page rate on WaveSpeed):
| Provider | Cost per Clip | Monthly Cost | Savings with Kinovi |
|---|---|---|---|
| WaveSpeed list | $3.60 | $7,200.00 | — |
| WaveSpeed page rate | $3.24 | $6,480.00 | — |
| Kinovi | $2.717 | $5,434.00 | $1,766/mo below list / $1,046/mo below page rate |
Scenario C: 200 Product Stills (2K) + 50 Short Videos (5s, 720p) / Month (Ecommerce / Ads Pipeline)
Nano Banana 2 at 2K (no search add-ons) plus 50 Seedance 2.5 clips:
| Workload Line | WaveSpeed List | WaveSpeed Page Rate | Kinovi |
|---|---|---|---|
| 200 × Nano Banana 2 (2K) | $21.00 | $18.90 | $14.14 |
| 50 × Seedance 2.5 (5s, 720p) | $90.00 | $81.00 | $67.93 |
| Combined Monthly Total | $111.00 | $99.90 | $82.07 |
The combined Kinovi estimate is 26.1% below WaveSpeed list and 17.9% below WaveSpeed's page rate. Switching to 4K stills or enabling WaveSpeed search add-ons changes only the image line.
Developer Migration Guide: Moving from WaveSpeed API to Kinovi
Migrating a Seedance 2.5 job requires updating the submit endpoint, the poll endpoint, and any upload or webhook handler—you cannot simply swap the base hostname on a WaveSpeed JSON payload.
Step 1: WaveSpeed Submit Request (Before)
WaveSpeed submits Seedance 2.5 text-to-video jobs to a model-specific path with top-level parameters:
curl --fail-with-body --connect-timeout 10 --max-time 60 \
-X POST "https://api.wavespeed.ai/api/v3/bytedance/seedance-2.5/text-to-video" \
-H "Authorization: Bearer $WAVESPEED_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"prompt": "A cinematic tracking shot through a city park after rain, soft cloudy light, wet pavement reflections, smooth camera movement.",
"aspect_ratio": "16:9",
"resolution": "720p",
"duration": 5,
"generate_audio": true
}'
WaveSpeed returns data.id. Your worker polls GET https://api.wavespeed.ai/api/v3/predictions/{id}/result until status is completed, then reads data.outputs.
Step 2: Kinovi Submit & Poll Request (After)
On Kinovi, every model goes to POST /api/v1/jobs/createTask with model: "seedance2-5" and settings nested under inputs (resolution → outputResolution, aspect_ratio → aspectRatio):
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": "A cinematic tracking shot through a city park after rain, soft cloudy light, wet pavement reflections, smooth camera movement.",
"aspectRatio": "16:9",
"outputResolution": "720p",
"duration": 5
}
}'
createTask returns a taskId. Poll recordInfo until status is success or fail:
curl -X GET "https://kinovi.ai/api/v1/jobs/recordInfo?taskId=TASK_ID" \
-H "Authorization: Bearer $KINOVI_API_KEY"
Exact Field & Status Mapping (WaveSpeed → Kinovi)
| WaveSpeed API | Kinovi API |
|---|---|
POST /api/v3/bytedance/seedance-2.5/text-to-video | POST /api/v1/jobs/createTask with "model": "seedance2-5" |
Authorization: Bearer API key | Authorization: Bearer API key |
prompt | inputs.prompt |
resolution | inputs.outputResolution |
duration | inputs.duration |
aspect_ratio | inputs.aspectRatio |
reference_images / reference_videos / reference_audios | inputs.imageUrls / inputs.videoUrls / inputs.audioUrls |
generate_audio | inputs.generate_audio on Flash; confirm on the 2.5 schema if relied upon |
standard_webhook query parameter | Top-level callBackUrl |
Poll data.id → completed + data.outputs | Poll taskId → success + output[].url |
created / processing | waiting / generating |
failed | fail |
POST /api/v3/bytedance/seedance-2.5/text-to-video. Source: WaveSpeed Seedance 2.5.
createTask and recordInfo, the input schema, and a cURL example for seedance2-5. Source: Kinovi Seedance 2.5.Production Submit-and-Poll Examples (TypeScript & Python)
TypeScript submit-and-poll wrapper for Kinovi:
const headers = {
Authorization: `Bearer ${process.env.KINOVI_API_KEY}`,
"Content-Type": "application/json",
};
const created = await fetch("https://kinovi.ai/api/v1/jobs/createTask", {
method: "POST",
headers,
body: JSON.stringify({
model: "seedance2-5",
inputs: {
prompt: "A cinematic tracking shot through a city park after rain.",
aspectRatio: "16:9",
outputResolution: "720p",
duration: 5,
},
}),
});
const { taskId } = await created.json();
for (;;) {
const res = await fetch(
`https://kinovi.ai/api/v1/jobs/recordInfo?taskId=${taskId}`,
{ headers: { Authorization: headers.Authorization } },
);
const job = await res.json();
if (job.status === "success") {
console.log(job.output);
break;
}
if (job.status === "fail") {
throw new Error(JSON.stringify(job.error));
}
await new Promise((r) => setTimeout(r, 2000));
}
Python submit-and-poll wrapper for teams migrating off the WaveSpeed Python SDK:
import os
import time
import requests
API_KEY = os.environ["KINOVI_API_KEY"]
HEADERS = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
}
resp = requests.post(
"https://kinovi.ai/api/v1/jobs/createTask",
headers=HEADERS,
json={
"model": "seedance2-5",
"inputs": {
"prompt": "A cinematic tracking shot through a city park after rain.",
"aspectRatio": "16:9",
"outputResolution": "720p",
"duration": 5,
},
},
timeout=60,
)
resp.raise_for_status()
task_id = resp.json()["taskId"]
while True:
poll = requests.get(
"https://kinovi.ai/api/v1/jobs/recordInfo",
params={"taskId": task_id},
headers={"Authorization": f"Bearer {API_KEY}"},
timeout=30,
)
poll.raise_for_status()
job = poll.json()
if job["status"] == "success":
print(job["output"])
break
if job["status"] == "fail":
raise RuntimeError(job.get("error"))
time.sleep(2)
5-Minute WaveSpeed-to-Kinovi Migration Checklist
- Generate a Kinovi API key in your Kinovi API dashboard to replace
WAVESPEED_API_KEYfor routed models. - Switch the submit endpoint from
POST /api/v3/{model_id}toPOST /api/v1/jobs/createTaskand pass"model": "seedance2-5"(or the target model id). - Nest parameters under
inputs—mapresolution→inputs.outputResolution,aspect_ratio→inputs.aspectRatio, and reference arrays toimageUrls/videoUrls/audioUrls. - Update your poller to
GET /api/v1/jobs/recordInfo?taskId=..., checking forstatus === "success"or"fail"and readingoutput[].url. - Validate one live job in staging and compare
creditsUsedon the task record against the rate table above before shifting production traffic.
Uploads, Safe Retries, Webhooks, and MCP
- Uploading local files: Both APIs accept public URLs or a two-step upload for local assets. WaveSpeed uses
POST /api/v3/media/uploadsfollowed byPUT(up to 200 MB, retained 7 days; WaveSpeed upload docs). Kinovi usesPOST /api/v1/uploadsfollowed byPUT, passing the returned URL ininputs(Kinovi Uploading Assets). - Never auto-retry a timed-out submit POST: WaveSpeed's retry guide warns that a dropped connection or 5xx on POST may still have created and billed a prediction, and public docs do not list an
Idempotency-Keyheader. Check History or recent predictions first. On Kinovi, persisttaskIdimmediately and restrict automatic retries toGET /api/v1/jobs/recordInfo. - Webhooks: WaveSpeed supports
standard_webhookHTTPS query parameters signed with Standard Webhooks and retried up to 3 times if your endpoint misses a 2xx within 10 seconds (WaveSpeed webhooks). Kinovi acceptscallBackUrloncreateTaskand sends one POST onsuccessorfailwithout retries—so treatrecordInfopolling as your source of truth. See the Kinovi API Reference for task status and webhook patterns. - MCP servers: Both platforms publish hosted MCP servers for Cursor and Claude—WaveSpeed at
https://api.wavespeed.ai/mcp(docs) and Kinovi athttps://kinovi.ai/api/mcp(docs).
Billing, Refunds, and Production Limits
Kinovi's billing model reserves the job price at submit, settles the charge on success, and returns the reservation in full on fail or cancellation. WaveSpeed's refund policy automatically reverses failed requests, system errors, and server-side timeouts. On both platforms, prepaid credits do not expire, and completed outputs you dislike are not automatically refunded. In WaveSpeed sync mode, if your HTTP client times out while the server prediction completes, retrieve the result by id—it is not auto-refunded.
| Operational Rule | WaveSpeed API | Kinovi API |
|---|---|---|
| Credit balance | Prepaid top-up; never expires | Credit packages; never expire; shared across Studio and API |
| Failed tasks | Auto-refund for failed requests, system errors, server timeouts | Reserved credits returned in full on failure or cancellation |
| Submit retries | Do not auto-retry POST; check prediction history first | Persist taskId and poll recordInfo; do not blindly resubmit |
| Webhooks | Signed (standard_webhook), up to 3 delivery retries | Single callBackUrl POST; not retried; poll recordInfo |
| Cancel in-flight work | Delete removes finished predictions only; does not cancel or refund running jobs | Billing docs cover refund on cancellation; no public cancel endpoint documented |
| Concurrency & rate limits | New accounts: Bronze (5/min, concurrency 2). Any top-up below $1,000 unlocks Silver (500/min, concurrency 300), then Gold/Ultra | New accounts: 3 concurrent waiting/generating tasks, no separate per-minute cap; higher tiers assigned on request |
| Output retention | Generated media generally expires in 7 days | Generated media retained 30 days, then deleted |
Takeaway: WaveSpeed's Silver tier (300 concurrent tasks after any top-up) is far above Kinovi's default new-account cap of 3. If your workload needs high burst concurrency immediately without requesting a tier increase, factor that into your rollout plan—and always copy outputs to your own object storage before expiration.
When You Should Stay on WaveSpeed (or Run Both)
Keep WaveSpeed—or run a dual-provider router alongside Kinovi—when any of these apply:
- Non-overlapping models: You depend on Veo, Luma, Meshy 3D, LLM routes, Topaz/specialized upscalers, or WaveSpeed-only Kling/MiniMax endpoints.
- Platform features: Your stack relies on WaveSpeed's official Python/JS SDKs, sync mode, pricing estimate API, signed Standard Webhooks with automatic retries, or IP-restricted API keys.
- Unlocked concurrency tiers: Your account is already at Silver, Gold, or Ultra and burst concurrency matters more than per-clip margin.
- Favorable live rates on specific models: For example, Seedream 5.0 Pro (lower on WaveSpeed at 1K and 2K) or WaveSpeed-only Nano Banana 2 0.5K/1K tiers.
Routing Seedance 2.5, Seedance 2.0/Fast/Flash, Kling 4.0, MiniMax H3, and Nano Banana 2 (2K/4K) to Kinovi while keeping the rest of your catalog on WaveSpeed is a low-risk hybrid architecture.
Other WaveSpeed API Alternatives Worth Comparing
If you are benchmarking more than two video generation API providers before committing engineering time—whether looking for a general WaveSpeed AI alternative or a specialized inference backend—compare the four main developer archetypes:
| Platform | Best For | Pricing Model | Tradeoff |
|---|---|---|---|
| Kinovi | Lowest verified rates on Seedance 2.5/2.0/Fast/Flash, MiniMax H3 & Nano Banana 2 (2K/4K) behind one createTask contract | Prepaid credits (never expire), Studio + API shared | Smaller catalog than aggregators; higher concurrency requires request |
| WaveSpeedAI | Broad multi-modal catalog (video, image, audio, 3D, LLMs), official SDKs, instant Silver concurrency | Prepaid credits (never expire), dual list/promo rates | Higher per-second cost on Seedance & MiniMax H3; 7-day retention |
| fal.ai | Fast serverless diffusion/video inference, mature JS/Python SDKs, custom model hosting | Usage-based per-second / per-compute | Per-endpoint schemas; check our fal.ai alternatives comparison |
| Replicate | Open-weights community models, custom Cog containers, broad experimental catalog | Per-second GPU billing or per-output | Cold-start variance on niche models; see Replicate alternatives |
| Direct vendor APIs | Single-family enterprise volume (BytePlus for Seedance, MiniMax, Kling, Google Gemini) | Direct vendor billing / enterprise contracts | Separate auth, quotas, billing, and integration per vendor |
WaveSpeed vs fal.ai
In a WaveSpeed vs fal.ai comparison, both platforms offer large model catalogs and official Python/JavaScript SDKs with per-model endpoints. fal.ai is strong when you need serverless GPU customization or fast diffusion iteration, while WaveSpeed is convenient for commercial video aggregators. Neither unifies Seedance, MiniMax H3, and Nano Banana 2 under one createTask payload at Kinovi's audited per-second rates.
WaveSpeed vs Replicate and Direct Vendor APIs
In a WaveSpeed vs Replicate evaluation, Replicate shines for open-weights community checkpoints and custom Cog deployments, whereas WaveSpeed focuses on hosted commercial video/image endpoints. Direct vendor APIs (BytePlus, MiniMax, Kling, Google Gemini) make sense only when single-family enterprise spend justifies maintaining separate auth, billing, and rate-limit stacks.
Who Kinovi Is Built For
Kinovi fits best for three specific developer profiles:
- Independent developers and studios who prototype Seedance or MiniMax clips in the browser and want the exact same credit balance to power backend API jobs.
- SaaS teams calling overlapping video models at scale (especially Seedance 2.5, Seedance 2.0/Fast/Flash, and MiniMax H3) who prefer one
createTask/recordInfowrapper—withcreditsUsedreturned directly on every task record—over maintaining per-model URL paths. - Ecommerce and ad-creative pipelines generating product stills and short-form clips together (Scenario C: Nano Banana 2 at 2K + batches of 5-second Seedance 2.5 clips) from one prepaid balance.
Frequently Asked Questions
What is the best WaveSpeed API alternative for Seedance and MiniMax video models?
For teams running Seedance 2.5, Seedance 2.0, Seedance 2.0 Fast, Seedance 2.5 Flash, Kling 4.0, MiniMax H3, or Nano Banana 2 (2K/4K), Kinovi offers 5.6%–53.8% lower published per-job rates (19.7%–53.8% below WaveSpeed list rates), one unified createTask / recordInfo API contract, 30-day file retention, and a shared Studio-plus-API credit balance. For broader catalogs (Veo, Luma, 3D, LLMs) or official SDKs, keep WaveSpeed alongside Kinovi or benchmark fal.ai and Replicate.
Can Kinovi replace every WaveSpeed model I use today?
Only where you can match version and mode on models both platforms publish. WaveSpeed also offers model families and tools (Veo, Luma, 3D, LLM routes, upscalers) that are not treated as Kinovi equivalents here.
Can I reuse my WaveSpeed JSON payload as-is on Kinovi?
No. You change the URL, pass the model id in the body, nest parameters under inputs (resolution → outputResolution, aspect_ratio → aspectRatio), and map status values (completed → success, failed → fail). Follow the Seedance 2.5 mapping in the migration section above and verify each model's schema before switching.
Does Kinovi have an official SDK?
Kinovi documents cURL, Python, and TypeScript examples on each model page and hosts an MCP server at https://kinovi.ai/api/mcp. WaveSpeed documents those examples as well and ships official Python and JavaScript/TypeScript SDKs.
Is there a free trial or free credits allowance?
WaveSpeed may grant $1 in free credits to eligible new users, though a new email alone does not guarantee free trial eligibility (account levels). Kinovi may provide a small starter grant of free credits depending on region (credits & billing). Always check the live offer in your account.
If a generation job fails, do I get my credits back?
Technical failure is refunded or not charged on both platforms. A completed output you dislike is not automatically refunded on either side, and a client-side HTTP timeout is not a server-side failure—especially in WaveSpeed sync mode.
Do credits expire, and can playground credits be used on the API?
Purchased credits do not expire on either platform. Kinovi shares one credit balance across Studio and the API. WaveSpeed bills playground and API predictions from the same prepaid balance and displays both in prediction history.
How long are generated video and image files stored?
WaveSpeed generally stores generated media for 7 days. Kinovi retains generated media for 30 days before deletion. Download and persist any assets you need long term.
Can I use generated outputs commercially, and are prompts used for training?
Commercial use depends on the underlying model provider's license and platform terms. WaveSpeed's FAQ states models are licensed for commercial use subject to each README and that WaveSpeed does not train AI on your data. Kinovi's Data Retention Policy states prompts, uploads, and results are not used to train models unless a specific model's documentation states otherwise.
Which WaveSpeed price should I use when comparing API costs?
Use the amount you will actually be charged. If a model page prints two figures, record both, note any OFF label on the Generate button, and state which column your budget assumes. Re-check the live model page before purchasing—WaveSpeed notes that documentation prices may lag and that the final task charge prevails.
Get Started with the Kinovi API
- Generate a Kinovi API key.
- Pick one high-volume model you already run on WaveSpeed—Seedance 2.5 is mapped step by step above.
- Run the
createTaskandrecordInfosnippet, download the output, and verifycreditsUsedagainst the published table. - Once that path is verified in staging, migrate the next overlapping model with the same wrapper.
Methodology & verification: All rates and policy rules were audited on 2026-11-20 directly from official self-serve model pages and documentation on WaveSpeedAI and Kinovi. Where WaveSpeed displays two rates, both the list rate and the lower on-page rate are reported. On Seedance 2.5, the lower 5-second 720p figure ($1.62) corresponds to the 10% OFF label on WaveSpeed's Generate button.
Related articles
More to try
Related models

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

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 Mini
Seedance 2.0 Mini is a low-cost video generation model built for fast drafting, batch iteration, e-commerce assets, short-video concepts, and reference-based creative workflows.
$0.0212/s

