Seedance 2.0 API Providers Compared: Who Actually Works in March 2026

Every week another blog post lists eight or ten Seedance 2.0 API providers as if they all work. Most of those lists were written before March 15, 2026, the day ByteDance suspended international API access following cease-and-desist letters from Warner Bros., Disney, and several other Hollywood studios over AI-generated videos that used unauthorized celebrity likenesses. The landscape changed overnight, and at least three providers that were previously operational immediately disabled the model. If you are evaluating Seedance 2.0 API access right now, the single most important thing you need to know is this: as of March 31, 2026, only two third-party providers have confirmed working access, the official ByteDance API has never been publicly available, and every third-party provider is using the same unofficial access method. This guide maps the real situation with verified data, explains the uncomfortable truth about how that access works, and gives you integration code designed to survive the next disruption.

TL;DR

As of March 31, 2026, the Seedance 2.0 API landscape looks nothing like what most comparison guides describe. The official ByteDance API remains unavailable after the Hollywood copyright dispute halted the planned February 24 global rollout. Only two third-party providers have confirmed working access: PiAPI at $0.12–$0.18 per second and laozhang.ai at $0.05 per 5-second 720p video. Three providers that were previously active — Kie AI, WaveSpeed, and BytePlus International — suspended Seedance 2.0 access on March 15. Three more — fal.ai, Replicate, and Atlas Cloud — have announced support but have not launched. If you need video generation right now and cannot wait, the safest approach is to build a provider-agnostic abstraction layer that lets you switch between Seedance 2.0 providers or fall back to Kling 3.0 by changing a single configuration line.

How We Got Here: The Timeline That Explains Everything

Understanding the current provider landscape requires knowing the sequence of events that created it, because each event eliminated options that used to exist. On February 12, 2026, ByteDance officially launched Seedance 2.0 on the Chinese domestic market through the Jimeng AI platform. The model immediately generated massive attention for its dual-branch diffusion transformer architecture that produces video and audio in a single forward pass, support for multi-shot storytelling within a single 15-second generation, and director-level camera controls including dolly zooms, rack focuses, and tracking shots that competing models struggle to replicate consistently.

ByteDance had planned to roll out the international Seedance 2.0 API through Volcengine on February 24, 2026. That rollout never happened. Between the domestic launch and the planned international date, viral AI-generated videos featuring highly accurate likenesses of celebrities circulated widely on social media, triggering intense backlash from Hollywood studios. Warner Bros., Disney, and several other major studios sent cease-and-desist letters to ByteDance, and the international API launch was indefinitely postponed. During this period, several third-party providers had already built integrations by reverse-engineering the Dreamina web application that ByteDance made available to international users, and these providers were serving real Seedance 2.0 requests through their own APIs.

The second major disruption came on March 15, 2026, when ByteDance tightened access controls on the Dreamina backend infrastructure. This was not a gradual change — it was a deliberate enforcement action. Providers that had been reliably serving Seedance 2.0 requests saw their access break simultaneously. Kie AI, WaveSpeed, Dzine AI, and BytePlus International all lost access to Seedance 2.0 within hours. Some providers adapted quickly by finding alternative access paths within ByteDance's infrastructure; others did not. The providers that survived — PiAPI and laozhang.ai — presumably invested more heavily in maintaining their reverse-engineering pipelines and adapted faster to the access changes.

The most recent development is ByteDance's March 26, 2026 announcement that Seedance 2.0 is being integrated into CapCut, ByteDance's consumer video editing platform, with a phased rollout starting in Brazil, Indonesia, Malaysia, Mexico, the Philippines, Thailand, and Vietnam. This matters for the API story because it signals that ByteDance is expanding distribution of the model rather than contracting it, which makes an eventual official API more likely rather than less likely. However, CapCut integration is consumer access, not developer API access, and no timeline has been announced for the latter.

The Uncomfortable Truth About Seedance 2.0 API Access

There is a fact that every comparison article about Seedance 2.0 API providers avoids stating directly, and it is the most important piece of context for any developer evaluating these services: there is no official Seedance 2.0 API. Not a restricted one, not a beta one — none at all. Volcengine's own create-task documentation page explicitly says that Seedance 2.0 "currently supports only the Ark experience center's free-quota testing and does not yet support API calls." The official models available through Volcengine's video generation API are Seedance 1.5 Pro and Seedance 1.0, not Seedance 2.0.

What this means in practice is straightforward: every third-party platform claiming to offer "Seedance 2.0 API" access is not calling an official ByteDance endpoint. The implementation method, confirmed by multiple technical analyses including a detailed writeup on apiyi.com, is reverse-engineering ByteDance's Dreamina web application. Providers intercept and replicate the requests that the Dreamina frontend makes to ByteDance's internal video generation backend, wrapping this access in a REST API that developers can call. This approach works, and the two providers listed as active in this guide do produce real Seedance 2.0 output, but it carries specific risks that you should understand before building production features on top of it.

The first risk is service continuity. Because no provider has a commercial contract with ByteDance for Seedance 2.0 API access, ByteDance can change authentication tokens, rate limits, or internal endpoint structures at any time without notice. When this happens, the provider's API breaks until their engineering team reverse-engineers the new structure. The March 15 shutdown of WaveSpeed, Kie AI, and several other providers was not a technical failure — it was ByteDance deliberately tightening access in response to legal pressure. The second risk is billing opacity. When a provider wraps reverse-engineered access in an API, you have no visibility into the actual generation pipeline. If a request fails silently on ByteDance's side, the provider's handling of that failure — whether they charge you, retry internally, or pass the error through — varies significantly. The third risk is feature parity. Seedance 2.0's full feature set includes multi-shot generation, native audio, and 15-second clips, but not all reverse-engineered endpoints expose all features. Some providers may silently downgrade parameters that their implementation cannot pass through.

For a deeper look at the official Volcengine Ark API path using Seedance 1.5 Pro as a production-ready interim solution, see our complete Seedance 2.0 API status guide, which covers the exact model IDs, code examples, and migration strategy for when the official 2.0 API does launch.

Every Provider Compared: What Actually Works in March 2026

The provider landscape for Seedance 2.0 API access falls into three clean categories as of March 31, 2026, and understanding which category each provider belongs to is the difference between building on a working foundation and building on a promise. The categories are determined by one simple test: can you make an API call right now and get a Seedance 2.0 video back?

PiAPI is the most thoroughly documented active provider. Their Seedance 2.0 integration uses the model identifier seedance-2-preview, with a separate seedance-2-fast-preview variant that trades some quality for speed. Authentication uses an X-API-Key header, and the endpoint accepts text-to-video and image-to-video requests with duration options of 5, 10, or 15 seconds and aspect ratios of 16:9, 9:16, 4:3, and 3:4. PiAPI's documentation at piapi.ai/docs is the most complete of any provider, including schema-validated request and response examples. The "preview" label on their model identifier is worth noting — it signals that PiAPI considers this access experimental, and pricing or availability may change. They offer free trial credits on signup, which lets you test before committing money.

laozhang.ai is the second confirmed active provider and currently the least expensive option by a significant margin. Their pricing starts at $0.05 per 5-second 720p video and scales to $0.30 per minute for 1080p and $0.80 per minute for 2K resolution. The API uses an OpenAI-compatible endpoint structure (POST /v1/video/text-to-video), which means integration code written for OpenAI's API pattern works with minimal changes. A significant differentiator is their failure billing policy: if a video generation request fails for any reason, including content policy violations, you are not charged. This matters more than it might seem — across all providers, generation success rates typically range from 85% to 95%, meaning that 5–15% of your requests may fail. On a provider that charges on processing start rather than completion, those failures cost money. Full API documentation is available at docs.laozhang.ai.

The suspended providers tell an important story about the fragility of this market. Kie AI, WaveSpeed, and BytePlus International all offered Seedance 2.0 access before March 15, 2026. WaveSpeed's pricing had been competitive at approximately $0.06 per second for 1080p with audio. Kie AI charged roughly $0.30 per request. BytePlus, ByteDance's own international cloud platform, offered Seedance 1.5 Pro via API at $0.494 per token without audio or $0.988 with audio, but never launched Seedance 2.0 API access. All three suspended service following ByteDance's enforcement action related to the Hollywood copyright dispute. There is no public timeline for restoration.

The coming soon category includes fal.ai, Replicate, and Atlas Cloud. fal.ai's Seedance 2.0 page at fal.ai/seedance-2.0 currently says "Coming soon" with no waitlist and "Pricing to be announced at launch." Replicate currently offers only Seedance 1.0 Lite, which generates 5-second and 10-second videos at 480p and 720p — a significantly older and less capable model. Atlas Cloud has published estimated pricing tiers ($0.022/sec for fast, $0.247/sec for pro) but is currently serving only Seedance 1.5 Pro.

One factor that separates the active providers from each other in practice is generation latency and what affects it. Typical generation times for a 5-second Seedance 2.0 video range from 30 seconds to 120 seconds depending on several variables: output resolution (720p is faster than 1080p, which is faster than 2K), server load at the time of request, and whether the provider adds their own queue management layer between your request and ByteDance's backend. Because both active providers are routing through reverse-engineered Dreamina endpoints, their latency is ultimately bounded by ByteDance's internal processing speed rather than by the providers' own infrastructure. This means that during peak usage hours on the Chinese internet — roughly 8 PM to 11 PM Beijing time, which corresponds to morning hours in US Eastern time — you may see longer generation times regardless of which provider you use. For comparison, Sora 2 generation takes 60 to 300 seconds for similar video lengths, and Kling 3.0 ranges from 30 to 90 seconds, making Seedance 2.0 through third-party providers competitive on speed when the backend is not under heavy load.

The feature coverage between the two active providers also differs in ways that matter for specific use cases. PiAPI explicitly supports video editing mode (taking an existing video as input and applying transformations), which laozhang.ai does not currently advertise. PiAPI also documents support for up to 9 images as input for multi-reference generation, matching Seedance 2.0's full multimodal input specification. laozhang.ai focuses on the core text-to-video and image-to-video workflows with simpler parameter sets, which makes their API easier to integrate but limits access to some of Seedance 2.0's more advanced capabilities. If your use case requires video editing or multi-reference generation, PiAPI is currently the only option. If you need straightforward text-to-video or single-image-to-video at the lowest cost, laozhang.ai is the clear choice.

Pricing Deep Dive: The Real Cost Per 10-Second Clip

Comparing pricing across Seedance 2.0 API providers is harder than it should be because every provider uses a different billing unit. PiAPI charges per second. laozhang.ai charges per video or per minute. Atlas Cloud uses a hybrid second-based model with tier multipliers. To make a fair comparison, this section normalizes everything to a single unit: the cost of generating one 10-second 1080p video clip, which is the most common production use case.

The normalized comparison reveals a significant spread. laozhang.ai comes in at approximately $0.60 per 10-second 1080p clip, calculated from their $0.30/minute rate for 1080p. PiAPI's fast mode costs $1.20 per clip ($0.12/sec × 10 seconds) while their standard mode costs $1.80 per clip ($0.18/sec × 10 seconds). For context, the leading alternative models price as follows: Kling 3.0 at approximately $0.50 per 10-second clip through its official API, and Sora 2 at roughly $5.00 per equivalent clip when accounting for the ChatGPT Plus subscription cost amortized across typical usage.

The failure billing difference deserves its own calculation because it materially changes your effective cost. Assume you generate 100 videos per month and experience a 10% failure rate, which is within the typical range reported across providers. On laozhang.ai, where failed generations are not charged, your cost for 100 successful videos at 1080p is 100 × $0.60 = $60.00. On PiAPI standard mode, where billing starts on processing, your cost includes the 10 failed attempts: 110 × $1.80 = $198.00 for the same 100 successful videos. This makes PiAPI's effective cost per successful video $1.98 rather than $1.80 — a 10% premium that compounds with scale.

Beyond per-clip pricing, there are resolution-dependent cost tiers worth understanding. laozhang.ai offers three tiers: 720p at $0.10/minute (the cheapest option for prototyping), 1080p at $0.30/minute (production standard), and 2K at $0.80/minute (maximum quality). PiAPI does not publish resolution-specific pricing in their current documentation, suggesting that the per-second rate applies regardless of output resolution. For developers doing rapid prototyping or generating placeholder content, the 720p tier represents a dramatic cost reduction — $0.05 per 5-second video means you can run 100 test generations for $5.00 total, which is practically free for evaluation purposes.

For a complete breakdown of consumer pricing options through Dreamina and Jimeng, including credit systems and daily limits, see our Seedance 2.0 pricing guide.

Integration Guide: Code That Survives Provider Shutdowns

The single biggest mistake developers make when integrating a video generation API is hardcoding the provider. When WaveSpeed suspended Seedance 2.0 access on March 15, every application that had hardcoded WaveSpeed's endpoint, authentication, and response format needed an emergency rewrite. The correct approach is to build a thin abstraction layer that separates your application logic from any specific provider's API contract. The pattern is simple: your application calls a generic generate_video() function, that function reads a configuration file to determine which provider to use, and the provider-specific details — endpoint URL, authentication header, request format, polling interval — live entirely in that configuration.

Here is a practical Python implementation of this pattern:

python
import os, time, requests

PROVIDERS = {
    "piapi": {
        "base_url": "https://api.piapi.ai/api/v1",
        "auth_header": "X-API-Key",
        "model": "seedance-2-fast-preview",
        "submit_path": "/task",
    },
    "laozhang": {
        "base_url": "https://api.laozhang.ai/v1",
        "auth_header": "Authorization",
        "model": "seedance-2.0",
        "submit_path": "/video/text-to-video",
    },
    "kling_fallback": {
        "base_url": "https://api.laozhang.ai/v1",
        "auth_header": "Authorization",
        "model": "kling-3.0",
        "submit_path": "/video/text-to-video",
    },
}

ACTIVE_PROVIDER = os.getenv("VIDEO_PROVIDER", "laozhang")
API_KEY = os.getenv("VIDEO_API_KEY", "")

def generate_video(prompt, duration=5, aspect="16:9"):
    cfg = PROVIDERS[ACTIVE_PROVIDER]
    headers = {cfg["auth_header"]: f"Bearer {API_KEY}"
               if cfg["auth_header"] == "Authorization"
               else API_KEY}
    resp = requests.post(
        f"{cfg['base_url']}{cfg['submit_path']}",
        headers=headers,
        json={"model": cfg["model"], "prompt": prompt,
              "duration": duration, "aspect_ratio": aspect},
    )
    resp.raise_for_status()
    task = resp.json()
    return poll_until_done(task, cfg, headers)

def poll_until_done(task, cfg, headers, timeout=300):
    task_id = task.get("task_id") or task.get("id")
    start = time.time()
    while time.time() - start < timeout:
        time.sleep(5)
        r = requests.get(
            f"{cfg['base_url']}/video/jobs/{task_id}",
            headers=headers,
        )
        data = r.json()
        status = data.get("status", "")
        if status == "completed":
            return data.get("video_url") or data.get("output", {}).get("url")
        if status == "failed":
            raise RuntimeError(f"Generation failed: {data}")
    raise TimeoutError(f"Timed out after {timeout}s")

The key design decision is the ACTIVE_PROVIDER environment variable. Switching from PiAPI to laozhang.ai — or falling back to Kling 3.0 entirely — requires changing one environment variable and restarting the process. No code changes, no redeployment of application logic. This pattern also makes it straightforward to implement automatic failover: if the primary provider returns errors for three consecutive requests, your orchestration layer can switch the environment variable and retry against the fallback.

The polling pattern deserves attention because video generation is inherently asynchronous. Unlike image generation APIs that return results in a single request-response cycle, video APIs use a submit-poll-download workflow. You submit a generation request and receive a task ID, then poll that task ID at regular intervals until the status changes to "completed" or "failed." The typical generation time for a 5-second Seedance 2.0 video ranges from 30 to 120 seconds depending on resolution, server load, and which provider you use. Setting your poll interval to 5 seconds and your timeout to 300 seconds covers the vast majority of cases without wasting API calls on overly aggressive polling.

Risk Management: What Happens When Your Provider Goes Dark

The March 15 suspension taught the market a concrete lesson: any provider offering Seedance 2.0 API access can lose that access without warning. If your product depends on AI video generation, you need a plan for this scenario that does not involve panic engineering at 2 AM on a Saturday. The risk management framework has three layers: monitoring, automatic failover, and graceful degradation.

Monitoring means checking your provider's health proactively rather than discovering outages through customer complaints. The simplest approach is a scheduled health check that submits a minimal generation request every 30 minutes and verifies that a video URL comes back within the expected timeout. If three consecutive health checks fail, your system should alert and prepare to switch. This is cheap to implement and catches both sudden shutdowns and gradual degradation.

Automatic failover is the abstraction layer pattern from the previous section extended with retry logic. When a generation request fails with a provider-level error (HTTP 503, connection refused, or timeout), the system retries once against the same provider, then switches to the fallback provider for subsequent requests. The fallback does not need to be another Seedance 2.0 provider — Kling 3.0 is a strong candidate because it has an official API with published SLA guarantees, generates 4K at 60fps, and costs approximately $0.50 per 10-second clip. Through laozhang.ai, you can access both Sora 2 at $0.15 per video and Veo 3.1 at $0.15–$0.25 per video as additional fallback options, with the same failure-free billing guarantee and OpenAI-compatible endpoint structure. Documentation for these video models is at docs.laozhang.ai.

Graceful degradation is what happens when all video generation providers are unavailable simultaneously. Your application should have a defined behavior for this scenario — showing a "generation temporarily unavailable, we'll notify you when it's ready" message is far better than a silent failure or a spinning loader that never resolves. Queue the request locally and process it when service restores, or offer the user a lower-quality alternative (a still image generated from the same prompt, for example).

When to Skip Seedance 2.0 Entirely

Not every project needs Seedance 2.0 specifically, and the current access situation makes the alternatives worth serious consideration. The right question is not "how do I get Seedance 2.0 API access" but "which video generation model best fits my actual requirements given realistic constraints?" Here is when each alternative makes more sense than pursuing Seedance 2.0 through unofficial channels.

Choose Kling 3.0 when you need a model with an official, commercially supported API and cannot accept the risk of reverse-engineered access. Kling 3.0 by Kuaishou offers native 4K at 60fps, a generous free tier for evaluation, and published API documentation with rate limits and SLA commitments. At approximately $0.50 per 10-second 1080p clip, it is the most cost-effective option with official backing. The tradeoff is that Kling's creative flexibility is narrower than Seedance 2.0 — it does not support the same level of multi-shot storytelling or complex camera movements in a single generation.

Choose Sora 2 when physics realism and longer clips matter more than cost. Sora 2 supports up to 25-second clips in a single generation and produces the most physically realistic motion among current models. The cost is substantially higher at roughly $5.00 per 10-second clip when amortized from a ChatGPT Plus or Pro subscription, but for applications where quality and clip length justify the premium — product demonstrations, architectural visualization, film pre-visualization — the output quality is unmatched for physical interactions.

Choose Veo 3.1 when you need enterprise features and Google Cloud integration. Veo 3.1 costs $0.75 per second through Google's Vertex AI, which translates to approximately $7.50 per 10-second clip — the most expensive option. However, it comes with SLA guarantees, HIPAA compliance options, and native integration with Google Cloud Storage and BigQuery for analytics. For enterprise applications that need audit trails and compliance documentation, Veo 3.1's price premium buys operational guarantees that no other provider offers. Through laozhang.ai, Veo 3.1 is also available at $0.15–$0.25 per video with the same no-failure-billing guarantee, making it accessible for developers who want Google-quality output without committing to Vertex AI's enterprise pricing tier.

The comparison table below normalizes the most important decision factors across all options. The "stability" column reflects whether the provider has a commercial contract with the model developer, which directly predicts how likely it is to break without warning.

The pattern that emerges from this comparison is clear: the unofficial Seedance 2.0 providers offer the best price-to-capability ratio by a wide margin, but they trade stability for that advantage. Official APIs cost 3–15 times more per clip but come with contractual backing that means your integration will not break overnight. Your decision depends on where your project sits on the cost-stability spectrum, and the provider-agnostic code pattern described earlier lets you position yourself at any point along that spectrum and shift as conditions change.

For a comprehensive side-by-side comparison of all four models including specifications, benchmark data, and detailed decision frameworks, see our complete 4-model comparison guide.

Decision Framework: Which Path Is Right for You?

After evaluating all the options, your decision reduces to a single question: how much operational risk can your project tolerate? The answer maps directly to three paths, each with clear tradeoffs that you can evaluate against your specific constraints.

Path 1: Use Seedance 2.0 via a third-party provider. This is the right choice if you specifically need Seedance 2.0's capabilities — its multi-shot generation, native audio, and creative control features — and you can accept the risk that access may be interrupted without notice. Start with laozhang.ai for prototyping (cheapest at $0.05/video, no failure charges) and consider PiAPI if you need the standard-quality tier or video editing capabilities. Build your integration using the provider-agnostic pattern from the code section above, configure Kling 3.0 as your failover, and implement health check monitoring. This path gets you running today with the best price-to-capability ratio, but it requires active risk management.

Path 2: Use an official model API and wait for Seedance 2.0 GA. This is the right choice if you need production stability and contractual guarantees. Build on Kling 3.0's official API now, which gives you excellent quality at $0.50 per clip with full commercial backing. Structure your code with the same provider-agnostic pattern so that switching to Seedance 2.0's official API — when it eventually launches — is a configuration change rather than a rewrite. ByteDance has announced that the CapCut integration of Seedance 2.0 began rolling out on March 26, 2026, starting with markets in Brazil, Indonesia, Malaysia, Mexico, the Philippines, Thailand, and Vietnam. This suggests the internal infrastructure is stabilizing, and an official API may follow in the coming months.

Path 3: Use multiple providers with automatic routing. This is the right choice if video generation is a core feature of your product and downtime directly impacts revenue. Maintain active configurations for both Seedance 2.0 (via laozhang.ai or PiAPI) and Kling 3.0, with automatic failover between them. Route requests based on feature requirements — use Seedance 2.0 when the user needs multi-shot or native audio, fall back to Kling 3.0 for standard single-shot generation. This maximizes both capability and reliability at the cost of maintaining two provider integrations instead of one.

Whichever path you choose, the provider-agnostic integration pattern protects your investment. The video generation market in March 2026 is moving fast — the CapCut rollout, the copyright dispute resolution, and potential new entrants like fal.ai will all reshape the landscape. Code that adapts to configuration changes will serve you regardless of which providers survive the next disruption.

Frequently Asked Questions

Is the official Seedance 2.0 API available anywhere?

No. As of March 31, 2026, ByteDance has not released an official Seedance 2.0 API for developer use. The Volcengine documentation explicitly states that Seedance 2.0 is limited to the Ark experience center's free-quota testing and does not support API calls. The official video generation API through Volcengine Ark currently supports Seedance 1.5 Pro and Seedance 1.0, not Seedance 2.0. All third-party providers offering "Seedance 2.0 API" access are using reverse-engineered integrations with ByteDance's Dreamina web application rather than an official API endpoint.

Why did so many providers suddenly stop working on March 15?

ByteDance deliberately tightened access controls on the Dreamina backend infrastructure on March 15, 2026, in response to cease-and-desist letters from Hollywood studios including Warner Bros. and Disney. The studios objected to AI-generated videos using unauthorized celebrity likenesses, and ByteDance's response included restricting the international access paths that third-party providers had been using. Providers that could not adapt to the new access restrictions lost Seedance 2.0 functionality immediately. This was not a bug or a temporary outage — it was a policy-driven enforcement action, which means restoration depends on legal resolution rather than technical fixes.

Which provider should I choose for production use?

If Seedance 2.0 specifically is required, laozhang.ai offers the best combination of low cost ($0.05/video for 720p) and developer-friendly policies (no charge on failed generations, OpenAI-compatible endpoint). If you need the most thoroughly documented API, PiAPI has the most complete documentation with schema-validated examples. If production stability and contractual guarantees matter more than using Seedance 2.0 specifically, Kling 3.0's official API is the safest choice. In all cases, use the provider-agnostic code pattern described in this guide so you can switch without rewriting your application.