---
title: Use CapCut with invideo
description: Send an MP4 from invideo to CapCut for mobile finishing, or bring a CapCut export into invideo for an agent-driven edit.
---
It depends on who finishes the video and where. CapCut is a video editor on mobile, desktop and the web, strong at quick edits, effects and finishing on a phone. invideo adds an agent that edits for you on a timeline, generation inside the same project, and branches a person reviews.

What crosses between the two is a rendered MP4. Nothing editable moves across: CapCut says it does not support importing or exporting project files from third-party editing software.

## When to use both

Use both when each tool does one half of the job. Common cases:

- **Agent first, phone last.** Your agent makes the cut in invideo. You add a trend effect or a last sticker in CapCut on your phone.
- **Phone first, agent next.** You cut the raw clips in CapCut. Your agent adds captions, music, a voiceover or more versions in invideo.
- **One master, many posts.** A CapCut edit becomes the master. invideo makes one branch per platform from it.

## Hand-off: from CapCut into invideo

In CapCut, click **Export** and choose the resolution. CapCut saves a video file. Then your agent brings it into invideo:

- **A public link.** `add_media` with `media_url`.
- **A file on your computer.** `start_upload` with the `file_name`, a PUT of the bytes to the `upload_url`, then `add_media` with the `upload_id`. In a terminal, `invideo asset upload <project-url> <file>`.
- **A file in a chat app.** You drag the file into the chat. It arrives through `file` on `add_media`.

Each file becomes a sequence in the project, with its own sequence URL. On a timeline's URL, `add_media` also puts it in that timeline's media bin.

The CapCut export is one flat clip. The agent cuts it again where it needs to, with `split_clip` and `delete_clip`, or finds the cuts with `media` `video.sceneSplit`.

Then the agent finishes it:

- **Captions.** `media` `audio.transcript`, then `add_captions` with slides and words.
- **Music.** `search_library` in `stock_music`.
- **Versions.** One branch per shape with `timeline_history`, then `set_timeline_settings` for the size.

## Hand-off: from invideo to CapCut

Your agent runs `export` with `format` `video`. The result is a 1080p MP4. The agent reads the export card for the download URL, and you open the file in CapCut as a new project.

For a phone, the agent sets `quality` and `target_lufs` on the export, and you send the file to the phone. In a terminal, `invideo notebook show` with `--out` saves it to a folder.

Captions, text and music arrive burned into the picture. To change a caption after the hand-off, change it in invideo and export again.

## Steps

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.

Your agent runs a dry run first. For any call that costs 1 credit or more, it tells you the price and waits for your yes. A call under 1 credit runs without asking, and your agent tells you what it cost.

<Steps>
<Step title="Bring the CapCut export in">
The agent calls `add_media` with the MP4. Expected result: a sequence URL.
</Step>
<Step title="Make a timeline on a branch">
The agent calls `new_timeline` at the size you post, then makes a branch with `timeline_history`. Expected result: a timeline URL on a branch.
</Step>
<Step title="Cut and add music">
The agent places the clip with `place_media`, cuts where you asked, and places music from `search_library`. Expected result: a new `state_token` after each `edit_timeline` call.
</Step>
<Step title="Caption the speech">
The agent prices `audio.transcript` with `dry_run`, starts it, and calls again after `retry_after_s` for the words. Then it sends `add_captions`. Expected result: a caption clip.
</Step>
<Step title="Pick and price the voice">
The agent runs `find_models` with the voice-over in words, picks one, and reads its inputs with `get_model`. A good pick is `elevenlabs_text_to_speech.elevenlabs_tts_v4`. The agent can search for others with `find_models`. It picks a `voice_id` with `search_library`, calls `generate` with `dry_run: true` and the real inputs, and tells you the price. Expected result: a price and no charge.
</Step>
<Step title="Make the voice">
The agent calls `generate` with `max_credits` set to that price and an `idempotency_key`. Expected result: a thread URL, then a sequence URL when the voice lands. The agent reads that URL with `read`, and never calls `generate` again to check.
</Step>
<Step title="Check, then export for CapCut">
The agent runs `check_timeline` and `capture` at each caption and cut, then calls `export` with `format` `video` and an `idempotency_key`. Expected result: an export card with status `completed`. You open that file in CapCut.
</Step>
</Steps>

The same export from a terminal:

```bash
invideo agent register <project-url> --name <name>
export INVIDEO_AS=<name>
invideo edit export <edit-url> --format video --quality 1080 \
  --target-lufs -14 --idempotency-key "to-capcut-v1" --json
invideo status <card-url> --wait
invideo notebook show <card-url> --out ./to-capcut
```

`<project-url>` comes from `invideo project new` or `list_projects`. `<name>` is the name you choose in `invideo agent register`. `<edit-url>` is the timeline's URL. `<card-url>` is `.sequences[0]` of the export answer.

The voice from a terminal:

```bash
invideo gen models <project-url> --query "voice-over from a script"
invideo gen model <project-url> \
  --model elevenlabs_text_to_speech.elevenlabs_tts_v4
invideo library search <project-url> \
  --library elevenlabs_text_to_speech_voices --query "calm"
invideo gen run <page-url> \
  --model elevenlabs_text_to_speech.elevenlabs_tts_v4 --dry-run \
  -i prompt=@script.txt -i voice_id=<voice-id>
invideo gen run <page-url> \
  --model elevenlabs_text_to_speech.elevenlabs_tts_v4 \
  -i prompt=@script.txt -i voice_id=<voice-id> \
  --max-credits <price> --idempotency-key voice-1
```

`<project-url>` is the same project. `<page-url>` is a page that `invideo notebook show <project-url>` lists. `<price>` is the price the dry run returns. `<voice-id>` is an `id` that `invideo library search` returns.

## When to stay in CapCut

Stay in CapCut when you edit by hand on your phone, and the job is a quick post with its templates and effects. A short edit with no agent, no branches and no generation is faster there.

Move to invideo when you want an agent to do the edit, a person to review it on a branch, or many versions from one cut.

## If something goes wrong

| Symptom | Fix |
| --- | --- |
| `add_media` with `media_url` is refused | The link must be public. Download the file, then upload it with `start_upload` and `add_media` with the `upload_id`. |
| A caption is wrong after the hand-off | Captions arrive burned into the picture. Change the caption in invideo and export again. |
| `get_model` or `generate` refuses the model as not found | Models retire. Run `find_models` with the job in words, use the best match, and tell the person which model you used. |
| Avoid: call `generate` again to check on a run | Instead: read the thread or sequence URL with `read`. A second `generate` starts a second paid run. |

## Related

- [When to use CapCut vs invideo](/compare/capcut)
- [Make a trend edit like CapCut: slow-mo, meme, freeze frame](/how-to/personal/trend-edit)
- [Repurpose one video for every platform, one branch each](/how-to/creators/repurpose-for-every-platform)
- [Add word-by-word captions](/how-to/creators/word-by-word-captions)
- [invideo for AI agents](/agents)