How to Make AI Videos: Two API Workflows and the Real Cost of a 15-Second Reel

“Make me a 15-second reel” sounds like one request. In practice, it is a small production pipeline: write a brief, generate or select shots, reject bad takes, assemble a timeline, add legible text and audio, export, and review the finished file. The reusable template should control timing, typography, logo, captions, and safe areas. The generative model should supply only the parts that benefit from generation.

This guide uses one concrete example: a 15-second, 9:16 reel introducing a developer tool. The three beats are a four-to-five-second hook, a product-use moment, and a final benefit or call to action. We compare two documented API routes—Runway Dev and Google's Veo 3.1 in the Gemini API —then show how to render the same template with either set of clips. Prices and model limits are an October 16, 2026 snapshot, not a guarantee of future availability. The code follows vendor documentation; we did not make paid generation requests or benchmark output quality.

Choose the production route first

For a one-off, an editor is usually simpler. Runway's web plans and Shotstack Studio templates are examples of visual routes. Do not divide a monthly subscription by one reel and call that its marginal cost: include unused credits, export limits, and your editing time. Use APIs when you need to create many variants from a product catalog, localization data, or a recurring content schedule.

The fixed template: what changes, what stays

Create a 1080 × 1920 canvas and a timeline with three slots. Keep the hook title, lower-third, end card, logo, font, brand colors, caption placement, and music/voice level in the template. Replace only the shot files, title, one benefit line, and destination URL per reel. Both priced API examples below generate 720p footage; exporting it at 1080 × 1920 does not restore detail that was never generated. Leave space for platform overlays near the top and bottom; preview on a phone before publishing.

An example shot brief for a coding-tool reel:

1. Hook (0–4 or 0–5 s): a cluttered editor or terminal becomes clear; on-screen title: “Ship without the busywork.”
2. Proof (next 5–6 s): show a specific workflow—issue, code change, passing test. If exact UI text matters, use a real screen recording instead of asking a video model to invent it.
3. Payoff (final 5–6 s): calm finished state; end card supplies the actual product name and URL as normal editable text.

Example generation prompt for the *visual* of the first shot: “Vertical close shot of a developer workspace at night. One monitor shows abstract code-shaped blocks, not readable UI text. Slow push-in, warm desk lamp, clean teal accents, no logos or captions, one continuous camera move.” Keep the headline out of the prompt; the renderer adds it reliably. For the proof shot, record the actual product if accuracy is essential. Generated hands, interfaces, and legible code can fail; review every frame rather than assuming a plausible-looking clip is factual.

API path 1: Runway Gen-4 Turbo from three starting frames

Runway lists Gen-4 Turbo as an image-to-video model. Its API pricing is 5 credits per generated second, and credits cost $0.01 each before applicable tax: $0.05/s. The documented Gen-4 Turbo output supports 5- or 10-second clips and a 720:1280 portrait ratio. Three 5-second generations therefore provide an exact 15 seconds of raw footage. The starting images can be product-approved frames, illustrations, or photographs you have rights to use; their creation cost is separate.

Install the Runway Node SDK and set RUNWAYML_API_SECRET on your server as the SDK documents. Replace the example image URLs with your own accessible starting frames. This simplified batch starts three jobs and waits for each result:

import { writeFile } from 'node:fs/promises';
import RunwayML from '@runwayml/sdk';

const runway = new RunwayML();
const shots = [
  { frame: 'https://assets.example.com/hook.png', prompt: 'Slow push-in; desk light turns on; one continuous shot.' },
  { frame: 'https://assets.example.com/workflow.png', prompt: 'Subtle camera drift; the workspace comes into focus.' },
  { frame: 'https://assets.example.com/payoff.png', prompt: 'Gentle pullback; clean, optimistic closing image.' },
];

for (const [index, shot] of shots.entries()) {
  const task = await runway.imageToVideo.create({
    model: 'gen4_turbo',
    promptImage: shot.frame,
    promptText: shot.prompt,
    ratio: '720:1280',
    duration: 5,
  }).waitForTaskOutput();

  const response = await fetch(task.output[0]);
  if (!response.ok) throw new Error('Could not download shot ' + (index + 1));
  await writeFile('shot-' + (index + 1) + '.mp4', Buffer.from(await response.arrayBuffer()));
}

Runway's task-output documentation says returned media URLs expire within 24–48 hours. Upload each accepted downloaded clip to your own storage and pass a stable asset URL to the renderer. In production, persist job IDs, handle failures and timeouts, cap spending, and require a person to accept the take before ordering a replacement. Never put API secrets in browser-side code.

API path 2: Google Veo 3.1 Lite, then trim

The Gemini API Veo guide documents portrait 9:16 output, asynchronous generation, and 4-, 6-, or 8-second clips for Veo 3.1 Lite. A 15-second request is not a supported clip length. Generate 4 + 6 + 6 = 16 seconds, use 4 + 6 + 5 in the final timeline, and pay for the full 16 seconds. At 720p, Google lists Veo 3.1 Lite at $0.05 per generated second , or $0.80 for one 16-second pass. The model is a preview offering and has no free API tier in that price table.

With the Google Gen AI JavaScript SDK , set GEMINI_API_KEY on your server and run:

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});
const shots = [
  { seconds: 4, prompt: 'Vertical developer desk, abstract code blocks, slow push-in; no text or logos.' },
  { seconds: 6, prompt: 'Vertical close shot of a real-looking workflow board, gentle pan; no legible UI text.' },
  { seconds: 6, prompt: 'Vertical finished workspace, warm light, steady closing frame; no text or logos.' },
];

for (const [index, shot] of shots.entries()) {
  let operation = await ai.models.generateVideos({
    model: 'veo-3.1-lite-generate-preview',
    prompt: shot.prompt,
    config: {
      aspectRatio: '9:16',
      resolution: '720p',
      durationSeconds: shot.seconds,
    },
  });
  while (!operation.done) {
    await new Promise((resolve) => setTimeout(resolve, 10000));
    operation = await ai.operations.getVideosOperation({ operation });
  }
  if (!operation.response?.generatedVideos?.[0]?.video) {
    throw new Error('Shot ' + (index + 1) + ' produced no downloadable video');
  }
  await ai.files.download({
    file: operation.response.generatedVideos[0].video,
    downloadPath: 'shot-' + (index + 1) + '.mp4',
  });
}

This follows Google's documented long-running-operation pattern, with an explicit check for an empty response. Add a spending limit and a retry policy before production. The Veo guide notes that generated files are retained for a limited time, so download them promptly. If you need a branded opening frame, use image-to-video; do not assume every reference-image or higher-resolution combination allows the same duration. Also check the current regional, person-generation, and content restrictions for your account.

Assemble one reusable reel

Both paths end with three reviewed MP4 files. Shotstack templates can save a timeline with merge fields for clip URLs and text; its Edit API renders a JSON timeline with tracks and clip start/length values. A template can place the three video slots at seconds 0, 4, and 10 for Veo, with lengths 4, 6, and 5. For Runway, use 0, 5, and 10, each 5 seconds. Set the output aspect ratio to 9:16 (API reference ), then overlay editable titles and a static end card. Render to a review URL first; publish only after checking crop, captions, audio, claims, and URL.

The alternative is a local FFmpeg or Remotion composition. Remotion provides React video templates , useful when the team already works in code; check its current license for company use. Local rendering removes a per-render API fee but still costs compute and maintenance. Whichever renderer you choose, use the same input manifest—three stable clip URLs, approved text, brand assets, and target duration—so changing the generation provider does not require rebuilding the whole template.

What does one 15-second reel actually cost?

These are API usage estimates, not subscription quotes or tested production bills. They assume all generated clips succeed and are accepted, no extra image generation, no paid voice/music, one 15-second Shotstack pay-as-you-go render, and no tax. Shotstack's public price is $10 for 50 rendered minutes, billed by the second, so 15 seconds of final rendering consumes $0.05 of that credit balance; the purchase is still $10. Its AI-generation charges are separate.

The last column shows first-pass total or three-pass total, not a range of guaranteed outcomes. Google's price table also lists $0.40/s for Veo 3.1 Standard at 720p: the same 16-second plan would be $6.40 before rendering. If only one shot needs replacing, pay for that shot rather than another full set. Budget staff time for review, subtitles, licensed audio, storage, and publishing separately. At ten reels per month, even a cheap first-pass calculation can be overwhelmed by repeated takes; record generated seconds per accepted reel as the operating metric.

A sensible first production run

Make one real reel manually before automating. Lock the template, produce the same brief through both APIs, and review the output for product accuracy, motion consistency, readable overlays, audio, and export quality. Record generated seconds, number of rejected takes, time to an approved cut, and final cost. If one provider wins for your content, automate only its repeatable steps: create jobs, persist their IDs, store outputs, replace template fields, render, and queue human approval. Keep a manual route for sensitive claims and clips where a screen recording is more truthful than synthetic footage.

Bottom line: The inexpensive part is often the final 15-second render. The variable cost is how many seconds you generate and reject before that render. A good AI-video workflow therefore treats generation as a source of shots and the template as the reliable publishing system.