Runway AI Video Generator: Cost, API and Code (2026)

The Runway AI video generator turns a written prompt or a still image into a short video clip, and it’s one of the tools that made AI video practical for working creators. This guide covers what it does well, what it costs, how to call it from code with a single API key, and when a different video model is a better fit.

What is the Runway AI video generator?

Runway is a company that builds generative video models and a creative app around them. Its model line has gone through several generations, from Gen-2 (one of the first widely used text-to-video models) through Gen-3 and Gen-4 to Gen-4.5. People searching for the Runway AI video generator usually mean one of two things: the web and mobile app, where you type a prompt and get a clip, or the underlying model, which developers can call through an API.

A few terms you’ll see throughout this guide:

• Text-to-video: you describe a shot in words and the model generates the frames.
• Image-to-video: you supply a still image as the first frame, and the model animates it according to your prompt.
• Video-to-video: you supply existing footage and the model restyles or edits it.
• Diffusion model: the family of models most video generators belong to. They start from random noise and remove it step by step until an image or video that matches the prompt appears. Modern versions do this in a compressed “latent” space, which is far cheaper than working on raw pixels.

Runway’s app wraps these models in an editor that also offers multi-shot generation, upscaling and workflow tools. If you only need the clips, and especially if you want to generate them from your own software, you can skip the app and call the model directly. On Unicorn API it appears as Runway, model id runway.

How the Runway AI video generator works

Whatever interface you use, every generation follows the same loop: you give the model an input, it renders for a while, and you get a clip back. The input decides how much control you have.

Starting from text

Text prompts are the fastest way to explore ideas. The model chooses the composition, lighting and subject details, so results vary a lot from run to run. That’s useful for brainstorming and frustrating when you need a specific product or character to look the same in every shot.

Starting from an image

Image-to-video gives you far more control. The first frame is fixed, so the model only decides what moves and how. Runway AI image to video is the usual route for product shots, animated illustrations and anything that has to match an existing brand look. A common workflow is to generate or design the still first, then animate it. Our guide to the real AI image generator models covers the still-image side.

Generation runs as a job

Video takes much longer to render than text or images, so APIs don’t hold your connection open while the clip renders. You submit a job, get an id back, and check its status until it’s finished. The Runway AI video generator works this way through Unicorn API, and so does every other video model in the model catalog. The pattern is the same no matter which model you pick.

Is Runway free, and how much does a clip cost?

This is the question most searchers actually have. There are two separate answers, depending on where you use the model.

In Runway’s own app

Runway’s app has usually offered a small free allowance to new users, then moved to subscription plans that come with a monthly bucket of credits. Each generation spends credits based on the model, length and settings. These terms change, so check Runway’s site for current details. In practice, the free allowance is enough to test the Runway AI video generator, but not enough to produce a real project.

Through Unicorn API

Unicorn API gives you one key and one bill for every image, video, audio and chat model, priced in credits. The Runway model has a flat price: 12 credits per video. Here’s what that means in dollars:

How you buy credits	Price per credit	Cost of one Runway video
Starter plan ($25/month)	$0.01	$0.12
Creator plan ($50/month)	$0.01	$0.12
Studio plan ($100/month)	$0.01	$0.12
Pro plan ($200/month)	$0.01	$0.12
Top-up credits (never expire)	$0.015	$0.18

The Starter plan gives you 2,500 credits a month, enough for about 208 Runway clips. Top-ups cost a little more per credit, but they never expire, which suits occasional use. Full details are on the pricing page.

You never have to guess what a request will cost. POST /v1/models/price returns the exact price of a request before you run it, which matters most for models whose price depends on duration and resolution.

How to use the Runway AI video generator through an API

Here’s the full flow, from no account to a downloaded clip. If you’d rather try prompts in a browser first, the video playground runs the same models without any code.

1. Create an API key on the keys page and export it as UNICORN_API_KEY.
2. Optionally, check the price of your request.
3. Create a job with POST /v1/jobs.
4. Poll GET /v1/jobs/{id} until status is "succeeded".
5. Download the video from job.outputs[0].url.

Check the price with curl

curl -X POST https://api.unicornapi.net/v1/models/price \
  -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
    }
  }'

The Runway model accepts these input fields: prompt, quality, duration, image_url, watermark and aspect_ratio. The "quality": "example" value above is a placeholder from the minimal request. Replace it with one of the accepted values listed on the Runway model page or in the API documentation.

Generate and download a clip in Python

import os
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {"Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}"}

body = {
    "model": "runway",
    "input": {
        "prompt": "A slow drone shot over a rocky coastline at sunset, waves breaking",
        "quality": "example",  # use an accepted value from /models/runway
        "duration": 1,
    },
}

resp = requests.post(f"{API}/v1/jobs", headers=HEADERS, json=body)
resp.raise_for_status()
job = resp.json()

while job["status"] != "succeeded":
    if job["status"] == "failed":
        raise RuntimeError(f"Job failed: {job}")
    time.sleep(5)
    job = requests.get(f"{API}/v1/jobs/{job['id']}", headers=HEADERS).json()

video_url = job["outputs"][0]["url"]
with open("runway_clip.mp4", "wb") as f:
    f.write(requests.get(video_url).content)

print("Saved", video_url)

Animate an image in JavaScript

For Runway AI image to video, add image_url to the input. Everything else stays the same.

const API = "https://api.unicornapi.net";
const headers = {
  Authorization: `Bearer ${process.env.UNICORN_API_KEY}`,
  "Content-Type": "application/json",
};

async function animate(imageUrl, prompt) {
  const res = await fetch(`${API}/v1/jobs`, {
    method: "POST",
    headers,
    body: JSON.stringify({
      model: "runway",
      input: {
        prompt,
        image_url: imageUrl,
        quality: "example", // use an accepted value from /models/runway
        duration: 1,
      },
    }),
  });
  let job = await res.json();

  while (job.status !== "succeeded") {
    if (job.status === "failed") throw new Error(JSON.stringify(job));
    await new Promise((r) => setTimeout(r, 5000));
    job = await (await fetch(`${API}/v1/jobs/${job.id}`, { headers })).json();
  }
  return job.outputs[0].url;
}

animate("https://example.com/product.png", "The camera slowly orbits the bottle as light glints off the glass")
  .then(console.log);

If you work inside Cursor, Claude Code or another coding agent, you can connect the API through MCP (Model Context Protocol, a standard way for agents to call tools) and have the agent create jobs for you. Setup is on the agents page.

Writing prompts that get good results

The Runway AI video generator responds best to prompts that read like a shot description, not a story. A story prompt asks for several events, while a clip shows one. Some habits that help:

• Describe one shot. Subject, action, camera movement, lighting. For example: “A slow drone shot over a rocky coastline at sunset, waves breaking.” Leave out cuts and plot twists.
• Name the camera move. Words like “slow push in”, “orbit”, “handheld” or “static locked-off shot” have a large effect on motion.
• Keep motion simple for image-to-video. The start frame already defines the scene. Your prompt should say what moves, not describe the image again.
• Match the aspect ratio to the destination. Use the aspect_ratio field for vertical social clips rather than cropping a wide video later and losing the subject.
• Change one thing at a time. When a result is close, adjust a single phrase. Rewriting everything makes it impossible to learn what helped.

A worked example: a 20-shot product teaser

Say you’re making a short teaser for a new water bottle. You design a hero still, then plan 20 image-to-video shots: an orbit, a slow push in, a splash, a top-down spin, and so on. Expect about two takes per shot.

• 40 generations at 12 credits each = 480 credits.
• On a monthly plan that’s $4.80. With top-up credits it’s $7.20.
• The Starter plan’s 2,500 credits leave plenty of room for re-shoots and alternate cuts.

Because the Runway price is flat per video, you can budget a storyboard by counting shots. That’s harder with per-second models, which is where the price endpoint earns its place.

Runway vs other AI video generators

Runway isn’t the only video model worth knowing, and the same API key reaches the others. Here’s how the Runway AI video generator compares with the other video models covered in this guide, using Unicorn API prices.

Model	Inputs	Length and resolution	Price
Runway	Text or start image	Set via duration and quality	12 credits per video, flat
Grok Imagine Video 1.5	Start image only	1 to 15 s; 480p, 720p, 1080p	2.4 credits per second at 480p, 4.5 at 720p, 8 at 1080p
Grok Imagine Video 1.0	Text or start image	6 to 30 s; 480p, 720p, 1080p	Same per-second rate as 1.5 (6 s at 720p is 27 credits)
Vidu Q4 Image To Video	Start image, optional audio	Per second; 540p up to 4K	7.2 credits per second at 540p, 15.2 at 720p, 19.2 at 1080p, 62.4 at 4K
Vidu Q4 Reference To Video	Reference images and audio	Per second; 540p up to 4K	Same per-second rates as Vidu Q4 Image To Video

When to pick which

• Runway fits short cinematic shots where a flat, predictable price per clip makes budgeting simple.
• Grok Imagine Video 1.5 has a very low cost per second and strong motion. A 5-second 480p draft costs 12 credits, the same as a Runway clip. It only animates a start frame, though, and it can be busy at peak times. Our Grok Imagine AI guide goes deeper.
• Grok Imagine Video 1.0 is the option when you need long takes, up to 30 seconds, or text-to-video at the Grok rate.
• Vidu Q4 was released on 2026-10-12. It’s the choice when you need 2K or 4K output. Its reference-to-video variant guides the clip with reference images, which helps keep a character or product consistent across shots. It’s also the most expensive per clip: 5 seconds at 720p comes to 76 credits.

For more on animating stills, see how Kling AI image to video works and our roundup of the AI animation video generator options. If your clips need sound, the AI sound effects generator guide shows how to add audio with the same key.

Common mistakes and trade-offs

Most wasted credits with the Runway AI video generator come from a handful of avoidable mistakes.

Mistakes

• Treating the prompt as a script. Asking for three events in one clip usually produces muddled motion. Generate three clips and cut them together.
• Skipping the start frame. If the subject has to look a specific way, use image-to-video. Hoping text-to-video lands on the right look burns takes.
• Polling too aggressively. Checking job status every few milliseconds doesn’t make the render faster. Poll every few seconds.
• Not handling failures. Jobs can fail. Your loop should stop and log the failure rather than spin forever. Add a timeout in production code.
• Leaving output URLs in place. Download the file and store it in your own storage instead of relying on the output URL long term.
• Guessing field values. Use the accepted values for quality and duration listed on the model page, not values copied from another model’s docs.

Trade-offs to weigh

• App vs API. Runway’s app gives you an editor, multi-shot tools and a visual timeline. The API gives you automation, batch generation and one bill across models. Teams often use both: the app to explore, the API to produce at volume.
• Flat vs per-second pricing. Runway’s flat 12 credits per video is easy to budget. Per-second models like Grok and Vidu can cost less for short, low-resolution drafts and more for long, high-resolution finals.
• Draft cheap, finish well. A practical pattern is to block out motion with a low-cost model at 480p, then render final takes with the Runway AI video generator or Vidu Q4 at higher resolution.
• Subscription vs top-ups. If you generate every month, a plan’s $0.01 credits are cheapest. If you work in bursts, top-ups cost $0.015 each but never expire.

Whichever route you take, the workflow stays the same: check the price, create a job, poll it, and download the result. Once that loop works for Runway, switching to another video model means changing the model id and its input fields. Nothing else in your code has to change.