---
title: Turn dailies into string-outs and selects
description: Your day's footage synced to the sound, laid out in slate order, circled takes marked, a string-out per scene and a selects reel, ready for your editing app.
---
You get your dailies organized for the edit: picture synced to the sound recorder, every take laid out in slate order, the circled takes marked, a string-out per scene, and a selects reel. This work is also called syncing dailies, an assistant editor's prep, or a string-out. Your agent does it on invideo timelines and hands it to your editing app as a project.
Use invideo for this when you want the prep done by your agent while you sleep: it reads the slates and the sound, builds a timeline per scene, and exports a project that Premiere Pro, DaVinci Resolve or Final Cut Pro opens.
## Quickest path
Set up your agent first with [invideo for AI agents](/agents). Then give it this prompt.
```text
Day 4 dailies are in ./day-04: camera files in ./day-04/A-cam and
./day-04/B-cam, sound in ./day-04/sound. Sync picture to sound, lay
the takes in slate order, mark the circled takes from ./day-04/notes.txt,
and make a string-out per scene and a selects reel. Price the
transcripts first. Then export a DaVinci Resolve project.
```
In a terminal, the agent uploads the folders itself, large files included. In a chat app, you drag the files into the project.
## What you need
Clear slates make this fast. The agent reads them from the picture and the sound.
- **The camera files.** Every card from the day.
- **The sound files.** The recorder's files, one per take.
- **The camera and sound reports.** Or a text file with scene, take, and which takes are circled.
- **The frame rate.** The project's frame rate, as a whole number like 24, 25 or 30. `new_timeline` and `invideo edit new --fps` take whole numbers, so a 23.976 project runs at 24 here and conforms in the NLE.
- **Your editing app.** Premiere Pro, DaVinci Resolve or Final Cut Pro.
## Steps
The agent works on one timeline for the day, then copies it per scene.
The agent uploads in three calls.
1. It makes the timeline with `new_timeline` at the project's frame rate.
2. For each large file, it calls `start_upload` and PUTs the bytes to the `upload_url`.
3. It calls `add_media` with the `upload_id` and the timeline URL.
Expected result: a sequence URL and a media bin id for every camera and sound file.
The agent runs `media` with `video.frames` on the first seconds of each camera file to read the slate board. Where the board is not in frame, it reads the spoken slate from the transcript. Expected result: scene and take for every file.
The agent finds the offset in two calls.
1. The agent prices `audio.transcript` with `dry_run` on the camera's own sound and on the recorder file, each by its sequence URL from `add_media`, and tells you the price. For a price of 1 credit or more it waits for your yes. Then it starts the transcript with `max_credits` set to that price, and calls again after `retry_after_s` for the words. The same words in both give the offset.
2. It confirms the offset on the slate clap with `audio.waveform`, where the clap is the sharp peak in both files.
Expected result: an offset in seconds for every take.
The agent places each take's picture with `insert_media` in scene and take order, and its recorder sound on an audio track at the offset. It links them with `link_clips` and names each clip with `set_name`, like "12A-3". It sends a scene in one `edit_timeline` call. Expected result: synced takes in slate order, and a new `state_token`.
The agent adds a marker on each circled take with `add_marker`, a color and a note from the camera report. It approves the circled takes in the notebook with `mark_sequence`, with the reason "circled". Expected result: markers on the timeline and approved takes in the notebook.
The agent copies the day's timeline per scene with `duplicate_timeline`, and on each copy removes the other scenes' takes with `delete_clip` mode `close_gap`. For the selects reel, it makes one more copy and keeps only the circled takes. Expected result: a timeline per scene, and a selects timeline, each with its own `timeline_id`.
The agent runs `capture` on a few takes per scene and listens for sync with `audio.waveform`. It runs `check_timeline`. Then it runs `export` with `format` set to `davinci`, `premiere` or `final_cut`, and `media_packaging` folder or zip. Expected result: an export card with status `completed` that lists the media zip.
The same job from a terminal:
```bash
invideo edit new --name "Day 04 dailies" --fps 25
invideo asset upload ./day-04/A-cam/* ./day-04/B-cam/*
invideo asset upload ./day-04/sound/*
invideo media video.frames --asset m3 --at 0,1,2 --out ./slates
invideo media audio.transcript --dry-run
invideo media audio.transcript --max-credits
invideo media audio.waveform --asset m3 --limit 160
invideo edit change --timeline T1 --token \
--operations @scene-12.json
invideo notebook mark --status accepted --reason "circled"
invideo edit capture --timeline --at 2,40
invideo edit export --format davinci --media-packaging zip \
--idempotency-key day-04 --json
invideo status --wait
invideo notebook show --out ./day-04-resolve
```
Where the values come from: `` from `invideo project new`, and `` from `invideo edit new`. `` is the `url` that `invideo asset upload` returns for each file; `m3` is its bin id, which the reads that return at once, such as `video.frames` and `audio.waveform`, take with `--asset`. `` is the price the dry run returns, its `estimated_credits`. `` comes from `invideo edit show `, read again after each change. `` is the take's sequence URL. `` is the `timeline_id` that `duplicate_timeline` gives each scene copy. `` is `.sequences[0]` of the export answer. `invideo status` waits but does not download; `notebook show` with `--out` saves the files. When `status` says `completed`, the media zip can still be packing, so run `notebook show` again until the zip is in the folder. The file in `--operations @scene-12.json` is a bare list of ops, like the `operations` list below.
The key MCP call lays one synced take and marks it. This fence is the full MCP `edit_timeline` call. The `at_f` values are frames at the timeline's frame rate, so the sound starts the offset earlier than the picture.
```json
{
"url": "",
"timeline_id": "T1",
"expected_state_token": "",
"operations": [
{ "op": "insert_media", "asset": "m3", "track": "V1",
"at_f": 4500, "ripple": true },
{ "op": "insert_media", "asset": "m41", "track": "A1",
"at_f": 4470, "ripple": true },
{ "op": "add_marker", "at_f": 4500, "color": "#e53935",
"name": "12A-3 circled", "note": "Best performance, soft focus end" }
]
}
```
The agent reads the new clip ids with `get_timeline`, then sends `link_clips` and `set_name` in the next call.
## Cost and time
Edits and exports are free. Generation and transcripts cost credits. Paid stock costs a small credit charge, or one of your workspace's iStock licenses. Your agent runs a dry run first and tells you the price before it spends anything.
- **Costs credits:** a transcript per file with `audio.transcript`. Skip it for takes with a clear slate clap, and the agent syncs them from `audio.waveform` alone.
- **Free:** uploads, the timelines, markers, approvals, string-outs and the project export. `video.frames` and `audio.waveform` show their price in the dry run before anything starts.
Uploading a day's cards takes the longest. The sync and the string-outs take the agent under an hour. See [Credits and what they cost](/account/credits) for prices.
## If something goes wrong
Most problems come from takes with no clap, or files the agent could not name.
| Symptom | Fix |
| --- | --- |
| A take is out of sync by a frame | Move the sound clip one frame with `move_clip`, then check the clap with `audio.waveform` again. |
| A take has no slate clap | The agent syncs it on the transcript words alone. Check it by eye with `capture`. |
| A file has no readable slate | The agent lists it for you. Tell it the scene and take. |
| Takes are out of order | Give the agent the camera report. It reorders with `move_clip`. |
| The project opens without media | It was exported with `none`. Export again with `folder` or `zip`. |
| An upload by URL fails on a large file | Use `start_upload`, then `add_media` with the `upload_id`. |
| The folder has the project file but no media | The zip was still packing. Run `invideo notebook show --out` again until the zip lands. |
| `audio.transcript` is refused as `not_found` | It got a bin id like `m3`. Pass the file's sequence URL instead. |
| CLI exit 7 | Nothing ran. Run the same command again. |
| Avoid: approving takes the report does not circle | Instead: mark only what the report or the director says. |
| Avoid: syncing by file time alone | Instead: confirm every take on the clap or the words. |
## Prompts to try
Each prompt is a real variation of the job.
```text
Sync the day's B-cam to the A-cam and the sound, stack them as separate
video tracks per take, and make a string-out for scene 14 only.
```
```text
Make a selects reel of every circled take from days 1 to 4, in script
order, with the slate name burned on each take.
```
```text
Find every take where the actor says "I never left". List them with
scene, take and timecode, and mark them on the timeline.
```
## When to use something else
invideo syncs by sound and by the slate, not by timecode. For a shoot with jam-synced timecode on every camera and recorder, a sync by timecode in DaVinci Resolve or Premiere Pro is faster.
For on-set color and dailies for everyone on set, use an on-set dailies tool such as DaVinci Resolve or Pomfort Silverstack.
## Related
- [Export to Premiere Pro, DaVinci Resolve or Final Cut Pro](/how-to/export-to-premiere-resolve-final-cut)
- [Edit a documentary or interview from the transcript, with b-roll and lower thirds](/how-to/film/documentary-and-interview-edit)
- [Color grade log footage and match shots](/how-to/film/color-grade-log-footage)
- [Create a first cut from raw footage](/guides/how-to-create-a-first-cut-from-raw-footage-in-invideo-editor)
- [Run invideo in CI and on servers](/how-to/ci-and-servers)