---
title: Make an employer brand film with real employees, and a video job ad per role
description: Cut employee interviews into an employer brand film with lower thirds in your brand style, then a 30 second video job ad per open role.
---
Turn interviews with your real employees into an employer brand film, or recruitment video, and a 30 second video job ad for each open role. Your agent reads the interviews, picks the honest lines, adds b-roll of the office and the team, and puts name and role lower thirds in your brand fonts and colors. The job ads reuse the film's best moments with the role's title and link on screen.
Use invideo for this when you hire for many roles: the job ad is one template timeline, and each role is a copy with new text, so a new opening takes minutes.
The agent never posts the film or the job ads to LinkedIn, your careers page or a job board. You publish them.
## Quickest path
Set up your agent first with [invideo for AI agents](/agents). Then give it this prompt.
```text
Cut the interviews in ./interviews into a 90-second employer brand film.
Pick honest lines about the work and the team, not slogans. Add b-roll
from ./office, lower thirds with name and role in my brand kit, and
captions. Then make a 30-second job ad for each role in roles.csv.
Price the transcripts first.
```
In a chat app, you drag the files into the project. In a terminal, the agent names the folders and uploads them.
## What you need
These are the inputs the agent asks for.
- The interview recordings, one file per person, with their consent to appear.
- Each person's name and role, spelled the way they want it.
- B-roll of your office, your team at work, or your product. Stock fills the gaps.
- Your brand kit: colors as hex codes, the font files, the logo.
- The open roles: title, team, location, and the link to apply.
- The shapes: 16:9 for the careers page, 9:16 or 1:1 for social.
## Steps
The agent cuts the film first, then makes the job ads from it.
### Cut the film
The agent builds the film on a branch.
The agent writes a context entry at `context/brands/acme.md` with `write`: colors, fonts, logo and text rules. It uploads the font files and the logo with `start_upload` and `add_media` on the timeline URL. Expected result: an entry URL, and a font id in the media bin for each font.
The agent uploads each interview with `start_upload` and `add_media`. It prices `audio.transcript` on each interview's sequence URL with `dry_run`, tells you the price, starts it with `max_credits` set to that price, and calls again after `retry_after_s` for the words. Expected result: every word with its time and speaker.
The agent reads each transcript and picks short, specific lines about the work, the team and growth. It skips lines that sound like an ad. It shows you the list with names and times before it cuts. Expected result: your yes, or your changes.
The agent makes a 16:9 timeline with `new_timeline` and creates a branch with `timeline_history`. It places each line with `place_media` and `linked_audio` true, and lays b-roll over the cuts on a higher track, with stock from `search_library` in `stock_video` for gaps. Expected result: a cut where every line is a full sentence.
The agent adds each person's name and role with `add_text`, then applies the brand font and colors with `set_text_style`. It adds captions with `add_captions` from the transcript words. Expected result: a lower third the first time each person speaks, in your brand style.
The agent runs `capture` at each lower third and `check_timeline`, then runs `export`. Expected result: an export card with status `completed`.
### Make the job ads
The agent builds one job ad template, then one copy per role.
The agent builds a 30 second job ad on its own timeline from the film's best moments, with a title card and an apply card made with `add_text`. For each role, it runs `duplicate_timeline`, reads the copy with `get_timeline`, and changes the cards with `set_text`. Expected result: one timeline per role.
The agent runs `find_models` with the job in words, picks one, and reads its inputs with `get_model`. A good pick is `elevenlabs_music_v2_5_instrumental`. It calls `generate` with `dry_run: true`, a `prompt` and a `duration` of 30, and tells you the price. Then it calls `generate` with `max_credits` set to that price and an `idempotency_key`. Expected result: a sequence URL, which the agent reads with `read` and places on `A2` (Music) in each copy.
The agent runs `capture` at each card and `check_timeline`, and reads each role title and link against your list. Then it runs `export` per timeline with `timeline_id`. Expected result: one export card per job ad with status `completed`.
The terminal version of the same job:
```bash
invideo project new --title "Employer brand"
invideo agent register --name
export INVIDEO_AS=
invideo context write /context/brands/acme.md \
--markdown @acme.md --description "Acme brand kit"
invideo asset upload ./interviews/*.mp4
invideo media audio.transcript --dry-run
invideo media audio.transcript --max-credits
invideo edit new --name "Brand film"
invideo asset upload ./brand/Inter-Bold.otf ./brand/logo.png
invideo gen models --query "instrumental music bed"
invideo gen model --model elevenlabs_music_v2_5_instrumental
invideo gen run --model elevenlabs_music_v2_5_instrumental \
--dry-run -i prompt="warm, hopeful, light piano" -i duration=30
invideo gen run --model elevenlabs_music_v2_5_instrumental \
--max-credits --idempotency-key job-ad-music-v1 \
-i prompt="warm, hopeful, light piano" -i duration=30
invideo edit show --json
invideo branch new --name film-v1 --token
invideo edit show --json
invideo edit change --timeline T1 --token \
--operations @film.json
invideo edit capture --at 3,20,45,80 --out ./frames
invideo edit check
invideo edit export --format video --quality 1080 --json
invideo status --wait
invideo notebook show --out ./film
invideo edit export --format video --timeline T3 --json
```
Where the values come from:
- `` comes from `invideo project new`, and `` from `invideo edit new`. `` is the name you choose in `invideo agent register`. `` is a notebook page from `invideo notebook show `.
- `` is the `url` the upload returns for each interview. Each `` is the dry run right before it.
- `` comes from `invideo edit show `, and on the branch from `invideo edit show `; the main token is stale there. `` is the `.branch_url` that `invideo branch new` returns.
- `` is `.sequences[0]` of what the export returns. `invideo status` waits and does not download; `invideo notebook show` saves `./film/export.mp4`, which the agent renames, like `brand-film.mp4`.
- `T3` is the id of a job ad copy, from what `duplicate_timeline` returns or `invideo edit show`. Each copy's export gets its own `status` and `notebook show`.
The brand kit entry is plain markdown. The agent and anyone in the project read it before they work.
```text
# Acme brand kit
- Colors: navy #1a2b4c, coral #ff6b5b, white #ffffff
- Font: Inter Bold for titles, Inter Regular for captions
- Logo: bottom right, never over a face
- Lower thirds: name in white, role in coral, left aligned
```
The file `./film.json` holds a bare list of operations. On the MCP path, the same list goes in the `operations` field of `edit_timeline`. This one adds a lower third on `V3` (Titles).
```json
[
{ "op": "add_text", "track": "V3", "start_f": 30, "end_f": 150,
"text": "Priya Nair, Backend Engineer" }
]
```
The agent reads the new text clip's id with `get_timeline`, because a later op in the same call cannot use it. In a second call it styles the clip with the brand font. Here `t1` is that id and `f1` is the font's id from `add_media`.
```json
[
{ "op": "set_text_style", "clip": "t1",
"style": { "font": "f1", "color": "#ffffff",
"font_size": 44, "align": "left" } }
]
```
On each job ad copy, the agent sends `set_text` with the copy's own clip id from `get_timeline`, like `{ "op": "set_text", "clip": "t4", "text": "Now hiring: Backend Engineer, Berlin" }`.
## 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.
- Free: the brand kit, every edit and copy, `capture`, every `export`.
- Costs credits: `audio.transcript` on each interview, each stock shot, and a music bed from `elevenlabs_music_v2_5_instrumental`.
The film takes a few hours with your review of the lines. Each extra job ad takes minutes. See [Credits](/account/credits) for prices.
## If something goes wrong
Most problems are a lower third in the wrong style, or a copy with the wrong ids.
| Symptom | Fix |
| --- | --- |
| A lower third shows the default font | The `font` id is wrong or missing. Read the bin's fonts with `get_timeline` mode `collection`, then run `set_text_style` again. |
| A line sounds cut off | Extend the clip to the end of the sentence from the transcript with `trim_clip`. |
| `set_text` changed the template, not the copy | Read the copy with `get_timeline` and its `timeline_id`, then use its clip ids. |
| `write` on the brand kit is refused | Someone changed it since your read. `read` it again and pass the new `revision`. |
| `audio.transcript` returns a status, not words | It is still running. Call again with the same file after `retry_after_s`. |
| `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. |
| Exit code 6, or `status` is `held` | A safety review, not a refusal. Wait, then run `invideo status --wait` again. Do not resend. If it ends `failed`, change the input the review flagged. |
| CLI exit 3 | The edit changed since your read, or the token is from main. Run `invideo edit show ` and use its `state_token`. |
| The saved file is called `./film/export.mp4` | `notebook show` always saves `./film/export.mp4`. Rename it per role. |
| Avoid: putting a person in the film who has not agreed | Instead: ask the person for the list of people who signed a release. |
| Avoid: changing `invideo_rules.md` for the brand | Instead: put the brand in `context/brands/`. The rules file is the person's. |
## Prompts to try
Each prompt is a real variation of this job.
```text
Make the job ads 9:16 for LinkedIn and Instagram, with the role title
at the top and the apply link on the last card.
```
```text
Three new roles opened. Add them to roles.csv and make the job ads
from the same template.
```
```text
Make a 15-second cut of the brand film for each team: engineering,
sales and support, using only that team's people.
```
## When to use something else
invideo does not post job ads, track applicants, or film the interviews. Use your applicant tracking system or job board to publish, and record the interviews with a camera or a recording tool. For release forms and consent, use your HR or legal process. For a subtitle file a job board asks for, see the SRT steps on the event recap page.
## Related
- [Cut an event sizzle reel and a town hall recap from one day of footage](/how-to/marketing/event-and-town-hall-recap)
- [Edit a documentary or interview from the transcript, with b-roll and lower thirds](/how-to/film/documentary-and-interview-edit)
- [Cut a customer testimonial or raw creator footage into an ad, or the case study set](/how-to/marketing/testimonial-to-ad)
- [Resize one master ad for every placement, with safe zones](/how-to/marketing/every-placement-from-one-master)
- [Check your video before you say it is done](/how-to/check-your-video)
- [Know the cost before you spend](/how-to/cost-before-you-spend)