An AI video API should turn a sentence into a finished, graded cut, not hand you a raw clip and leave the editing to you. CoreReflex exposes its agentic Director through a public API and SDK, so one line of intent becomes a boarded, quality-checked, deterministically rendered film with a trace you can replay. This guide covers what the API actually does, how the Director loop runs, where credits enter the picture, and how to weigh it against other text-to-video tools.
What a real AI video API should do
Most "text to video" endpoints return a single generated clip, that is the easy 20 percent. The hard 80 percent, the part that decides whether the output is usable, is everything around generation: breaking the idea into shots, choosing camera moves, scoring each result against concrete checks, regenerating the weak ones, holding continuity across cuts, and rendering a final file your storage owns.
A production-grade AI video API has to own that whole arc. CoreReflex does, because it runs the entire stack on Google Vertex AI. Gemini for reasoning, Veo and Kling for video, Imagen for stills, Lyria for music, plus embeddings, speech-to-text, and text-to-speech behind one seam. You call one API; the orchestration handles the rest.
The unit of value is not a clip, it is a finished cut you can ship, plus the evidence of how it was made.
If you are wiring this into an app, start with the CoreReflex API quickstart and the full API reference in the docs, then come back here for the conceptual model.
Inside the agentic Director loop
The core of the API is an agentic Director that runs a four-stage loop: PLAN, PRODUCE, CRITIQUE, ASSEMBLE. Each stage is a discrete, inspectable step rather than a black box, and you can intervene at any point.
PLAN
You submit a sentence, say, "a 20-second product teaser for a matte-black water bottle, cinematic, sunrise light." The Director boards the film: it decides how many shots the story needs and writes a spec for each one, including its role in the edit, the camera move, and the generation prompt. Planning returns structured data you can read and adjust before a single credit is spent.
A minimal request looks like this:
POST /v1/films
{ "prompt": "20s cinematic teaser, matte-black water bottle, sunrise",
"aspect": "16:9", "duration": 20 }The response is a board of shots, not a video yet.
PRODUCE
For each boarded shot, the Director generates video on the appropriate Vertex model, passing through camera intent. Kling's camera_control, for example, so a "slow push-in" is actually produced, not merely described. Continuity is enforced by anchoring the last frame of one shot as the seed for the next, so cuts stay coherent instead of jumping between unrelated worlds.
CRITIQUE
This is the stage that separates a demo from a deliverable. Every shot passes a quality gate and is scored on concrete checks, prompt match, sharpness, motion coherence, on-screen text legibility, on-brand, and claims-risk. Shots that fail are selectively regenerated. The loop fixes the one weak shot; it does not throw away the eight good ones and start over.
ASSEMBLE
Approved shots are assembled into a timeline and handed to a deterministic render path. The result is a single graded cut plus an asset record. Because the cut is described by a manifest, the same manifest always renders the same video.
Free to plan, credits to generate
A deliberate part of the model: planning, scoring, and editing are free. Youonly spend credits when the system actually generates pixels or audio on a model, that means you can board a film, inspect every shot spec, restructure the timeline, and re-plan as many times as you want without burning budget, the meter starts at PRODUCE.
This matters for anyone integrating at scale. You can let users iterate on structure cheaply and gate the expensive step behind a confirmation. For the details on metering, batching, and keeping spend predictable, see API credits and cost control explained, and check current rates on the pricing page.
Provenance and renders you can trust
Two properties make the API safe for client and production work.
First, provenance you can replay. Every generation carries a portable trace, the model, the prompt, the parameters, and the score it earned at the quality gate. You can audit why a shot looks the way it does, reproduce it later, or hand the trace to a client as evidence.
Second, a deterministic render path. A real Remotion render worker claims the job, renders the manifest, and uploads the finished file to storage you control, writing an asset row you can fetch by ID. The path includes retry and a dead-letter queue so jobs are not silently lost, faststart for instant web playback, encoder tiers, and GPU acceleration. Same manifest in, same cut out.
Once a render is in flight, you poll for status, covered step by step in polling render job status via the API.
Editing the result as data
The output is not a dead file. The whole editor state is exposed as a programmable JSON engine, so you can read and mutate a project as structured data, swap a shot, change a caption, retime the cut, and re-render. If you are building automation on top of CoreReflex, this is the surface you want; start with the JSON engine and editing video as data and programmatic editor control with JSON.
How to evaluate an AI video API
When you compare text-to-video APIs, judge them on the parts that decide shippability rather than the demo reel:
- Does it return a finished cut or a raw clip? Assembly, grading, and continuity should be the API's job, not yours.
- Is there a quality gate? Look for explicit per-shot scoring and selective regeneration, not a single best-effort generation.
- Can you reproduce a render? Demand a provenance trace and a deterministic manifest, not a one-time URL.
- Who owns the output storage? The finished asset should land in storage you control.
- Is iteration cheap? Free planning with credits only on generation keeps experimentation affordable.
- Can you script it? A JSON engine, public API, API keys, and an SDK turn one-off generation into a repeatable pipeline.
Manage access the way you would any production credential, see creating, scoping, and rotating API keys safely. For the wider developer picture, browse the developer blog.
Frequently asked questions
Is there an API to generate video from text?
Yes. CoreReflex offers a public API, API keys, and an SDK that take a text prompt and return a finished, graded cut, not just a raw clip. The agentic Director boards the shots, generates them on Vertex AI, scores each one at a quality gate, and assembles the result through a deterministic render path.
Does generation cost credits while planning stays free?
Correct. Planning, scoring, and editing are free; you only spend credits when the system generates video, images, or audio on a model. You can board a film, inspect every shot, and restructure the timeline as many times as you like before committing to the generation step.
Can I edit the API result programmatically?
Yes. Editor state is exposed as a JSON engine, so a project is structured data you can read and mutate, swapping shots, retiming the cut, or changing captions, and then re-render deterministically. This is how teams build automated, repeatable video pipelines on top of the platform.
How do I check on a render that is still processing?
Renders run asynchronously. You submit the job and poll its status endpoint until the worker reports completion and writes the asset row, at which point you fetch the finished file from your storage. The render path includes retry and a dead-letter queue so a transient failure does not lose your job.
Start building
A good AI video API collapses the distance between an idea and a finished film while leaving a trail you can audit. CoreReflex does that end to end, agentic planning, a quality gate on every shot, replayable provenance, and a deterministic render, all behind one public API on an owned Vertex stack. Start free with no credit card and ship your first generated cut today.