Runway Text to Video AI (2026): Prompts, Cost and API Code

Runway text to video AI takes a sentence like “a slow drone shot over a rocky coastline at sunset” and returns a short video clip that matches it, with real camera motion, lighting and physics. This guide explains what is actually happening when you press generate, how to write prompts that give you usable shots instead of wobbly ones, what a clip costs, and how to call Runway from your own code with a single API key.

What is Runway text to video AI?

Runway is a New York company that builds generative video models and the creative app that wraps them. Its text-to-video feature is the headline product: you type a description, and the model produces a few seconds of footage from nothing. A related mode, image-to-video, starts from a picture you supply and animates it.

Runway’s models have moved through several generations. The older Gen-3 Alpha and Gen-3 Alpha Turbo were retired in July 2026, which is why many tutorials from 2024 and early 2025 now describe features you can no longer find. Newer generations, including Gen-4.5 announced in late 2025, focus on more cinematic motion and better prompt following. If you are following an old guide and a button is missing, that is usually the reason.

There are two ways to use Runway text to video AI:

• The Runway app. A browser editor with a prompt box, camera controls, a timeline and tools for stitching clips into a short film. Best if you want to work by hand.
• An API. You send a prompt and settings over HTTP and get a video file back. Best if you are building a product, running batches or letting an AI agent generate footage. Unicorn API exposes Runway this way, alongside other video models, under one key and one bill.

Both give you the same core ability: describe a shot in words, get a clip. The difference is whether a person or a program is driving.

How text-to-video AI models work

You do not need the maths to use these tools well, but a rough mental model helps you write better prompts and understand the failures.

Most modern text-to-video AI models are diffusion models. A diffusion model learns to reverse noise: during training it sees real videos gradually buried under random static, and it learns to remove that static step by step. At generation time it starts from pure noise and “denoises” toward a clip that matches your prompt.

Three pieces matter:

1. A text encoder turns your prompt into numbers that capture meaning. “Drone shot” and “aerial view” land near each other; “close-up” lands somewhere else.
2. A latent space. Rather than working on full-resolution pixels, the model works on a compressed representation, which is called a latent. This is what makes generation affordable at all. A latent diffusion model refines this compressed version, then a decoder turns it back into frames.
3. Time as a dimension. Unlike image models, video models refine all frames together so that motion is consistent. This is the hard part. When it goes wrong you see the classic artefacts: hands that change finger count, objects that melt into the background, or a person who turns into someone else halfway through.

Two practical lessons follow. First, the model is matching patterns it saw in training footage, so prompts written in the language of film (“tracking shot”, “shallow depth of field”, “golden hour”) work better than abstract ideas. Second, longer clips give errors more time to accumulate, so short, focused shots are more reliable than long ones.

How to write prompts for Runway text to video AI

The most common reason people are disappointed with text to video AI generators is the prompt, not the model. A clip is a single shot, so write a single shot.

Use a five-part structure

A reliable order is: camera, subject, action, setting and light, style. For example:

Slow dolly-in on an elderly fisherman mending a net on a wooden pier, early morning fog, soft diffused light, muted film colours.

Each part does a job:

• Camera: static, slow pan left, handheld, drone flyover, dolly-in, orbit. Pick one movement.
• Subject: who or what, with one or two defining details. “A red vintage motorbike”, not a paragraph of specs.
• Action: one clear verb. Mending, running, pouring, turning toward camera.
• Setting and light: where and when. Time of day is one of the strongest levers you have.
• Style: film stock, colour grade, documentary, anime, product commercial.

Camera language that the model understands

Runway’s own learning material leans heavily on camera movement and framing, and for good reason: these words map directly onto footage the model has seen. Terms that tend to work well include wide establishing shot, close-up, over-the-shoulder, low angle, top-down, tracking shot, slow push-in, and rack focus. Combining two moves (“pan left while zooming in and orbiting”) usually confuses it.

What to leave out

• Multiple scenes. “He walks in, sits down, then the camera cuts to the window” is three shots. Generate three clips.
• Text on screen. Signs, logos and captions are often garbled. Add text in editing.
• Negatives. “No people” can make people appear, because the word is now in the prompt. Describe what you want instead: “an empty street”.
• Adjective piles. “Stunning, breathtaking, ultra-detailed, epic” adds little. Concrete nouns help more.

When to switch to image-to-video

If you need the same character, product or set across several clips, pure text is a gamble because each generation interprets the words afresh. Generate or photograph a start frame first, then animate it. On Unicorn API, Runway accepts an image_url for exactly this.

How to use Runway text to video AI through an API

If you want to generate clips from code, a script or an agent, the API route is simpler than it sounds. Video generation takes a while, so it is asynchronous: you submit a job, get an ID straight back, then poll until the video is ready.

Step 1: get a key

Create an API key on the keys page and export it in your shell:

export UNICORN_API_KEY="your-key-here"

Step 2: submit a job with curl

The Runway model accepts these input fields: prompt, quality, duration, image_url, watermark and aspect_ratio. This is the minimal request body:

curl -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "runway",
    "input": {
      "prompt": "A slow drone shot over a rocky coastline at sunset, waves breaking",
      "quality": "example",
      "duration": 1
    }
  }'

Replace quality, duration and, if you want one, aspect_ratio with values listed on the Runway model page or in the API documentation. The response includes a job ID.

Step 3: a complete Python script

This script submits a Runway job, polls until it finishes, and downloads the video.

import os
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {
    "Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}",
    "Content-Type": "application/json",
}

body = {
    "model": "runway",
    "input": {
        "prompt": "A slow drone shot over a rocky coastline at sunset, waves breaking",
        # Use quality and duration values listed on /models/runway
        "quality": "example",
        "duration": 1,
    },
}

# 1. Submit the job
resp = requests.post(f"{API}/v1/jobs", headers=HEADERS, json=body, timeout=30)
resp.raise_for_status()
job_id = resp.json()["id"]
print("Job submitted:", job_id)

# 2. Poll until it succeeds
while True:
    job = requests.get(f"{API}/v1/jobs/{job_id}", headers=HEADERS, timeout=30).json()
    status = job["status"]
    if status == "succeeded":
        break
    if status == "failed":
        raise RuntimeError(f"Job failed: {job}")
    print("Status:", status)
    time.sleep(5)

# 3. Download the result
video_url = job["outputs"][0]["url"]
video = requests.get(video_url, timeout=120)
with open("coastline.mp4", "wb") as f:
    f.write(video.content)
print("Saved coastline.mp4 from", video_url)

To animate your own picture instead, add "image_url": "https://..." to the input object and describe only the motion in the prompt.

Step 4: check the price before you run

Every request can be priced in advance with POST /v1/models/price, so you can show users a cost or cap a batch before spending anything. The request shape is in the docs. If you work in Cursor, Claude Code or another coding agent, you can also connect it to the API over MCP from the agents page and let it submit and poll jobs for you. Prefer clicking? Try the same prompt in the video playground first.

What Runway text to video AI costs per clip

On Unicorn API, Runway is priced at 12 credits per video, charged per output. What a credit costs depends on how you buy it:

How you pay	Price per credit	One Runway clip (12 credits)
Monthly plan (Starter $25, Creator $50, Studio $100, Pro $200)	$0.01	$0.12
Top-up credits (never expire)	$0.015	$0.18

So the $25 Starter plan’s 2,500 credits covers about 208 Runway clips, with change left over. That matters more than it sounds: good text-to-video work involves generating several takes of every shot and keeping the best one, so the price per attempt is what you should budget around, not the price per finished scene.

A practical rule: plan on three to five generations per shot you actually use. A ten-shot short film might therefore take 30 to 50 Runway generations, or roughly 360 to 600 credits. Full plan details are on the pricing page.

Runway vs other text-to-video AI models

Runway is one of several strong text-to-video AI models, and each has a different shape. Other well-known names include Google’s Veo, Kling and xAI’s Grok Imagine, plus template-driven text to video AI generators such as InVideo that assemble stock footage and narration rather than generating new pixels. Here is how the video models on Unicorn API compare, using only their listed prices and options:

Model	Starts from	Length and resolution	Price	Example cost
Runway	Text, or text plus an image	Set via duration, quality and aspect_ratio fields	12 credits per video	12 credits
Grok Imagine Video 1.0	Text or image	6 to 30 s; 480p, 720p, 1080p	From 14.4 credits (6 s, 480p)	6 s at 720p: 27 credits
Grok Imagine Video 1.5	Image only (start frame)	1 to 15 s; 480p, 720p, 1080p	From 2.4 credits (1 s, 480p)	5 s at 720p: 22.5 credits
Kling 4.0 Flash Keyframe To Video	Prompt plus a first frame	720p	17 credits per second	5 s: 85 credits
Kling 4.0 Flash Reference to Video	Prompt plus reference images, elements or videos	720p	17 credits per second, or 11.3 with video_urls	5 s with video_urls: 57 credits

How to choose

• Pure text, predictable cost: Runway. A flat 12 credits per video makes budgeting simple, and it handles cinematic camera language well.
• Longer text-to-video clips: Grok Imagine Video 1.0 runs up to 30 seconds, which Runway is not built around. A 30-second 480p clip is 72 credits.
• Cheapest way to animate a still: Grok Imagine Video 1.5 starts at 2.4 credits for one second at 480p. It is image-to-video only, and it can be busy at peak times.
• Exact control of the opening frame: Kling 4.0 Flash Keyframe To Video takes a first_frame_url.
• Consistent characters or restyling existing footage: Kling 4.0 Flash Reference to Video accepts reference images, elements and source videos, and can keep the original sound.

Because all of these sit behind the same key and the same POST /v1/jobs call, switching is a one-word change to the model field. The fair way to compare text to video AI models is to send the same prompt to two or three of them and look at the results side by side on your own subject matter. Browse the full list in the model catalog, and if Kling is your main interest, the Kling API pricing breakdown goes deeper.

Common mistakes with Runway text to video AI

Most failed generations come from a handful of repeatable errors. Fix these and your keep rate goes up noticeably.

1. Writing a story instead of a shot. The model makes one continuous take. Split narratives into separate prompts and edit them together.
2. Asking for too much motion. Fast action, crowds and complex hand movements are where artefacts appear first. Slow, deliberate movement looks more cinematic anyway.
3. Ignoring aspect ratio. Decide whether you are making a vertical social clip or a widescreen shot before generating. Cropping a wide clip to vertical later throws away most of the composition.
4. Expecting consistency from text alone. The same character prompt will produce a slightly different person each time. Use a start image via image_url, or a reference model, when continuity matters.
5. Judging from one take. Generation is random. Budget for several attempts per shot before deciding a prompt does not work.
6. Following outdated tutorials. Guides built on Gen-3 Alpha describe features that were retired in 2026. Check that the advice matches the current model before copying settings.
7. Polling too aggressively. In code, check job status every few seconds rather than in a tight loop, and add a timeout so a stuck job does not hang your app.

A worked example: a five-shot coastal short

To see how the pieces fit together, here is a realistic workflow for a 15 to 20 second mood piece about a fishing village, built with Runway text to video AI and a little help from another model.

1. Write a shot list

1. Wide drone shot over a rocky coastline at sunset, waves breaking.
2. Slow push-in on a weathered wooden pier, fishing boats moored, warm backlight.
3. Close-up of hands coiling rope, shallow depth of field, golden hour.
4. Low-angle tracking shot of gulls circling above the harbour.
5. Static wide shot of the village lights coming on at dusk, blue hour.

2. Generate takes

Run each prompt through Runway three times. That is 15 generations at 12 credits, so 180 credits, or $1.80 on a monthly plan. A loop around the Python script above, swapping in each prompt, handles this without supervision.

3. Fix the weak shot

Suppose the hands in shot 3 look wrong in every take, which is common. Instead of more text prompts, take the best frame you like, then animate it with Grok Imagine Video 1.5 for 4 seconds at 720p (18 credits), or pass it to Runway as an image_url with a prompt that only describes the motion.

4. Edit

Pick the best take of each shot, trim to the strongest two to four seconds, add music and any titles in your editor. The whole piece, including retries, costs around 200 credits.

The lesson generalises: text-to-video works best as one step in a workflow, with a shot list in front and an edit behind, and with a fallback model ready for the shots text alone cannot nail.