---
name: bildy-storyboard-to-clips
description: Take a script, a product idea or a rough outline and turn it into a run of short clips that cut together, by generating a frame for every shot first and animating each one. Use when someone wants a short ad, an explainer, a trailer or any video made of several shots rather than one clip.
---

# A script into a run of clips

A video model gives you one shot at a time, usually four to ten seconds. A
video with five shots in it is five generations that have to look like they
came from the same camera. You get that by making all five still frames first,
on one image model, and animating them afterwards.

## Why the frames come first

An image costs a fraction of what a clip costs, and you get it in seconds
instead of minutes. Getting the look right on stills, where a re-run is cheap,
saves you re-running clips at twenty times the price. Five frames from one
image model with one prompt style also match each other far better than five
clips generated independently.

## Steps

1. Get the script, or write one with them. Break it into shots and keep each
   shot to one action. Five to eight shots is a sensible short video.
2. Write a style line you will paste into every shot prompt: the film stock,
   the light, the colour, the lens. Something like "shot on 35mm, overcast
   daylight, muted greens, shallow depth of field".
3. Generate one frame per shot with `images_generate`, each prompt being the
   style line plus that shot's description. Use the same model and the same
   `ratio` for all of them. Show the person all the frames together.
4. Fix whichever frames they do not like before you animate anything.
5. For each approved frame, call `videos_generate` with the frame's link as
   `imageUrl` and a prompt describing only the motion in that shot.
6. Poll `videos_get_job` on each. Clips take minutes, so tell them where you
   are rather than going quiet.
7. Join the clips into one file with `videos_compose`, passing the links in
   shot order. Poll `videos_get_edit` until it is done and hand over the
   finished video. Links expire after an hour.

If they would rather cut it themselves, skip step 7 and hand over the clips in
shot order with the shot number on each.

## Planning a one-clip video on a storyboard

If the whole video fits in one generation, you can plan its shots on a
storyboard and skip the separate frames. Call `videos_make_storyboards` with
the prompt, the clip length and its shape. Poll `images_get_job`, show the
person the storyboards and let them pick one. Then call `videos_generate` with
the same prompt and the chosen storyboard's url as `storyboardUrl`. The model
follows the panels in order, so one clip can hold two or three shots with cuts
between them.

We send the storyboard to the model as a reference picture, so pick a model
with `maxReferenceImages` above 0 in `videos_list_models`. The storyboard's
link expires after an hour, like every other link here.

## Costing it up front

Call `videos_list_models` and multiply the per-second price by the total
seconds before you generate anything. A five shot video at six seconds a shot
is thirty seconds of video, and the difference between a cheap model and an
expensive one across thirty seconds is large. Tell them the figure and let
them pick the model.

## Making consecutive shots carry on from each other

Two clips generated from the same style line still jump at the join, because
the second one invents its own opening frame. To have one carry on from the
last, take the closing frame of the first with `videos_extract_frame` and pass
its link to `videos_generate` as the `imageUrl` for the second. The second clip then
starts on the frame the first one ended on.

Do this where the same character or the same room appears on both sides of a
cut. Do not do it where you want a cut to a different place, because there the
jump is the point.

## Cutting between shots

Give consecutive shots different framings, wide then medium then close. Two
clips at the same distance cut badly.

Keep camera motion in one direction across a sequence. A push in followed by
another push in reads as one move; a push in followed by a pull back reads as
a mistake.

Leave a beat at the start and end of each clip with little motion. An editor
needs somewhere to cut, and a clip that is moving hard at both ends is hard to
place.