Stability AI Video API: Stable Video Diffusion From Code

What is callable today

Stability AI's Stable Video Diffusion API stopped being callable on 2025-07-24. Stability AI's pricing update page, read 2026-08-09, is the source for that date, and it states plainly that there is nothing left to measure on this endpoint. Stability lists no successor video-generation route in its place, on that page or anywhere else this record checked.

The TPL-30 benchmark this article uses to compare rendering tools has no run for Stability AI, and none can be created: the endpoint that would have produced an output file for ffprobe to inspect is gone. Every other tool measured for this benchmark, Editframe, FFmpeg, MoviePy and Remotion, returned a file with a duration, a frame rate, a codec, and a byte count. Stability AI returned nothing to point a measurement at. That is the finding this article works from, not a footnote attached at the end of it.

The gap also marks a category boundary worth naming precisely. Stable Video Diffusion generated short clips from a still image or a text prompt, using a model Stability hosted on its own infrastructure. FFmpeg, MoviePy, Editframe and Remotion do a different job: they composite assets a developer already supplied, a still image, pre-built text layers, a caption bar, and an audio track, into a fixed timeline, and none of them invents pixels the developer did not provide. A reader searching "stability ai stable video diffusion api" is asking about the first category, a generative model behind an API call. A reader searching "stability ai video api" more broadly could mean either category without realizing they are different. Right now, only the second category, compositing from supplied assets, has anything a developer can actually call.

For a build decision made this week, that narrows to one point: nothing in Stability's video catalog is production-ready, because nothing in it is callable. A team still pointing traffic at the old endpoint is not looking at a deprecation window with time to plan a migration inside. It is looking at an outage with no scheduled fix: the page that announced the removal documents no plan to bring the endpoint back.

What the vendor's own page says

The page carrying this information is titled as a pricing update, not as a deprecation notice: the URL path is /api-pricing-update-25, and Stability filed it under its pricing section rather than a changelog or a dedicated status page. Read 2026-08-09, it lists 2025-07-24 as the date Stable Video left the API catalog, alongside other pricing and catalog changes from the same period, rather than as a standalone announcement with its own page.

Stability's page records a discontinued endpoint and a date, without words like "temporarily paused" or "under review," and without any cushioning language beyond that. It does not commit to a replacement either: no line points a developer at a successor video-generation product inside the same catalog, and no migration guide links from the same page.

That combination, a dated fact the page states without softening language and without a forward pointer, is not the usual shape of a vendor discontinuation notice. Vendors more often bury a removal inside a plan-comparison table, or leave confirmation to a support forum thread rather than the pricing page itself. Here the removal sits on Stability's own pricing surface, which is why this article can cite it directly instead of relying on a secondhand report of the removal.

A reader checking this claim independently should expect to find two facts on the same page: the 2025-07-24 date, and the absence of any currently sold plan that includes Stable Video generation. A detail found only on third-party sites, such as a specific error message the dead endpoint returned or a promised return date, carries less weight than the two facts above: this record did not confirm it against Stability's own page.

What that leaves for anyone who built on it

A pipeline that called Stable Video Diffusion for a rendering step now fails at that call. No amount of retrying, or of rotating keys and switching regions, fixes it, because the service behind the call no longer exists. The failure is permanent rather than intermittent, and that changes how a team should respond to it: this is not a case for exponential backoff, it is a case for removing the call entirely.

Anything generated through that endpoint before 2025-07-24 is also fixed in place. A clip produced from a prompt and a seed cannot be regenerated later with a small edit, because the model that produced it no longer runs behind the API. Teams that treated Stable Video output as an intermediate asset, something to re-run when a brief changed, lose that option completely. The rendered clip stands as the final version, whether or not it still fits the current brief.

Rewriting the integration is not a matter of swapping one endpoint URL for another with a similar signature. Stable Video Diffusion took a prompt or a source image and a seed, and returned a generated clip; a developer supplied intent, not finished assets. Every tool measured on the TPL-30 benchmark in this record (Editframe, FFmpeg, MoviePy, Remotion) takes the opposite kind of input: a still image, pre-built text layers, an audio track, and a timeline that says when each one appears. None of them accepts a text prompt and returns new footage. Moving from Stable Video Diffusion to any tool in this comparison means building the assets the old pipeline never needed: a background image, rendered text, a caption bar position, an audio bed. That is new production work, not a client-library version bump.

This gap has no first-party migration guide to close it. The vendor's own page, described in the previous section, does not link a successor product, so a team cannot follow a documented path from the old integration to a new one inside the same account. The rewrite has to define its own inputs from scratch, decide which of those inputs a compositing tool can accept, and rebuild the render step around that shape, a scope closer to a new feature than a routine upgrade.

What still renders on this benchmark

Four tools produced a playable file on the fixed TPL-30 benchmark, measured on 2026-08-09 and 2026-08-25: Editframe, FFmpeg, MoviePy and Remotion. None of them generates video from a prompt. Each composites the same input set, a still image, three pre-rendered text PNGs, a caption bar drawn over the still, and a 30-second audio bed, into the same output shape: 1920×1080 at 30 fps, 30 s, H.264 video with AAC audio, CRF 20.

Tool	Version	Wall time	Output size	Output duration	Cost
Editframe	0.59.40	17.9 s	1.46 MB	30.080 s	$0
FFmpeg	8.0.1	7.5 s	0.99 MB	30.000 s	$0
MoviePy	2.1.2	86.6 s	1.01 MB	30.000 s	$0
Remotion	4.0.507	18.2 s	1.50 MB	30.059 s	$0

Sourcevideobycode TPL-30 benchmark runs vbc-2026-08-25-editframe-tpl30-001, vbc-2026-08-09-ffmpeg-tpl30-001, vbc-2026-08-09-moviepy-tpl30-001, vbc-2026-08-09-remotion-tpl30-001, measured 2026-08-09 and 2026-08-25

Sourcevideobycode TPL-30 benchmark runs(measured 2026-08-09 and 2026-08-25)

None of these wall-time numbers compares directly to what a bare encoder call alone would produce, and two of the four runs say so in their own notes. The Editframe and Remotion wall times include a browser launch, not just an encode. Editframe's 17.9 s covers a Vite dev-server start, a Playwright-driven system Chrome launch, 900 frame captures and a WebCodecs encode. Remotion's 18.2 s covers a webpack bundle, a headless Chromium launch, the same 900 frame captures, and an encode through Remotion's own bundled FFmpeg rather than the system binary. FFmpeg's 7.5 s is a single-pass filter graph with no browser in the loop, which accounts for most of the gap. MoviePy's 86.6 s streams raw frames from Python to the same system FFmpeg binary the FFmpeg run used, and the interpreter loop is the cost: composition happens frame by frame in Python before any bytes reach the encoder.

Two of the four outputs also missed the 30-second spec. Editframe's file measured 30.080 s against a defined 30 s, and Remotion's measured 30.059 s against the same target; both runs log this as a recorded deviation rather than a pass. FFmpeg and MoviePy landed on 30 s exactly. None of these differences would be visible by eye, but a pipeline that asserts exact frame counts downstream, a fixed-length ad slot for example, would need to test against the actual output duration rather than the spec duration.

Cost for each of the four runs came to $0, because every tool ran on a free or open-source tier with no cloud render minutes billed. That figure describes one 30-second render on one local machine. It says nothing about what a render farm processing a queue of these jobs would cost per finished video, and no run in this record measures that.

How to check this yourself

The fastest way to confirm whether Stable Video Diffusion is back is to read Stability AI's pricing page directly, not a comparison table that lists it as available. Comparison tables and tool directories copy prices and availability from each other more often than they check the vendor's own page on the date of publishing, and a discontinued date on one page does not automatically propagate to every page that once listed the product.

Two things on the vendor's own page settle the question without ambiguity: whether Stable Video appears as a line item under a currently sold plan, not just in historical documentation still indexed by a search engine, and whether the page carries a specific dated status change, the way the 2026-08-09 snapshot behind this article does. A third detail is worth checking separately: whether the same page links a successor product. Its absence here is informative on its own, because it means no in-catalog upgrade path exists to follow.

A third-party comparison table is the wrong place to settle this because it has no mechanism to catch a removal the day it happens. A table gets built once, from whatever the vendor's page said at build time, and then ages while the vendor's own page keeps updating. This record's own citation, a snapshot read on 2026-08-09, carries the same risk in the other direction: it is accurate as of that date and could be stale by the time this article is read, which is why the citation names a snapshot date instead of asserting the state is current indefinitely.

The compositing tools measured in this record and the discontinued generation API solve different problems. Picking among the compositing tools depends on the deployment target and on whether a browser dependency or a Python runtime already fits that environment, factors that rule out a single blanket recommendation for a team that depended on Stable Video Diffusion.

Stability AI's video endpoint no longer returns anything to call; Stable Video Diffusion access closed and no successor API replaced it under that name. Treat that shutdown as final rather than a temporary outage, and stop building new pipelines against the Stability video API or planning around its pricing. The compositing tools this benchmark did measure — FFmpeg, MoviePy, Editframe, Remotion — cover the overlay and caption work the API was doing here, though none of them generate video from a prompt the way Stable Video Diffusion did. Route new work through whichever of those already sits in the stack, and treat any code still pointed at Stability's video endpoint as dead and due for removal.

What we didn't test

• Stable Video Diffusion's former output quality, generation time, and per-clip cost against the four compositing tools it once competed with, because no endpoint remains to call.
• Templates built from multiple video clips, longer runtimes, vertical or square aspect ratios, or live-drawn text on an FFmpeg build that carries libfreetype.
• Paid cloud rendering, GPU-accelerated encoding, or concurrent job queues; every cost figure above comes from a single local render on a free or open-source tier.
• Pricing, output quality, or current availability for other AI video-generation APIs, the category Stable Video Diffusion belonged to before removal.
• Editframe's cloud tier, Remotion's paid licensing tiers, or any hosted rendering service layered on top of FFmpeg or MoviePy.

Questions people ask