---
name: video-description-product-list
description: "Build the product list for your video description with Vivu: when each product first appears, the model read off the box, a chapter line and an empty link column. Use before you publish."
---Product list for your video description
This skill takes one to three of a creator's own unboxing, review or favorites videos (the local exports) and the creator's draft list of products, which is usually incomplete, and returns a product list for the description: one row per product with the episode and source file, the time it first appears as MM:SS, the brand and model text read from a full frame of the packaging or the product (blank when nothing readable is printed), one line copied from the local transcript where the creator introduces it, the frame path, a chapter line in the form "MM:SS Product name", and an empty buy_link column. Claude prices the indexing against the user's Vivu plan, indexes the files in a private Vivu project, runs one speech search per product on the list and one search for items being shown to the camera, checks every window against the transcript and against frames, reads the model text from frames, and writes product_list.csv and a description block. The creator fills in the links and pastes the block into the description.
The value is in what the transcript leaves out. Creators say "the next thing I got is this" and "this one", and the product name sits only on the box, on the product, or on a card the editor added. Auto captions mishear brand names, so a model name copied from captions can come out wrong. And the draft list misses things: the power adapter that came in the box, a small extra item the creator unwrapped between two others. So the speech search finds where each listed product is introduced, the frames decide what the product is called, and a second search for things held up to the camera looks for items the list forgot. Nothing reaches the list without a transcript line or a frame that shows it.
When to use
Use when a creator asks "make the product list for my description from these two videos", "what time does each product show up in this haul, I need chapters", "read the model names off the boxes so I can add affiliate links", or "check whether I forgot any product in my list for this episode".
Not for these:
- One question about one video ("when do I open the charger?"): search Vivu directly or scrub the video.
- Proving a sponsor read to a brand. The sponsor-read-proof-sheet skill (https://vivu.ai/skills/sponsor-read-proof-sheet) does that.
- Live shopping replays with a pin log. The live-shopping-product-index skill (https://vivu.ai/skills/live-shopping-product-index) indexes those.
- Picking a thumbnail frame. The thumbnail-frame-candidates skill (https://vivu.ai/skills/thumbnail-frame-candidates) does that.
- Someone else's videos or a platform link. This skill reads only the creator's own local files.
- Finding buy links, writing affiliate disclosures or posting the description. The creator does those.
- Planning B-roll before the edit (which mentions still need a shot). This skill works on the finished video for its description.
Working principles
- Report measured numbers, not estimates. When a number is an estimate, say so.
- Nothing is verified until it has been checked against the video. A speech window is a candidate until the transcript shows the creator talking about that product; an item from the camera search is a candidate until a frame shows it. Vivu's reason text paraphrases and can name text that is not on the box, so it never fills a cell.
- Model text comes only from a full frame. When the frame does not show it clearly, the cell stays blank and says why; a wrong model in a description sends viewers to the wrong product.
- Stop and tell the user when a required capability or tool is missing. Do not guess around it.
- Ask the user before anything that is expensive to redo (the indexed minutes, before upload) and before anything that acts on their behalf. The skill writes local files only; the creator adds the links and publishes.
What you need before starting
Check each item at the start of the run and tell the user plainly what is missing before doing anything else.
| Requirement | Why | How to check |
|---|---|---|
| Vivu connector with write access | create a private project, open its upload page, search | vivu_get_account shows can_create_projects: true (tool names may carry a server prefix). A write call failing with "has not granted vivu.write" means the user reconnects Vivu and allows write access |
| A shell with ffmpeg and ffprobe | measure the videos, make contact sheets, extract frames | ffmpeg -version, ffprobe -version |
| The videos as local files, the same edit the viewers will see | Vivu indexes uploads, frames are read from the user's copy, and chapter times must match the published video | ls VIDEO_DIR shows the files; the user confirms they are the final exports |
| A transcript per video: the .srt the editor exported, captions the creator downloaded for their own upload, or a local speech to text tool such as whisper.cpp | the intro line is copied from the transcript, and speech windows are checked against it | an .srt or .vtt per video, or whisper-cli --help |
| The creator's draft product list, one line per product per video (a rough name is fine) | each product gets its own speech search | the user pastes it |
| An upload path | move the videos into Vivu | vivu_open_upload_page plus the user's own browser, or a browser tool that can attach local files |
This skill needs Claude Code on the user's computer (the terminal or the Code tab of Claude Desktop), because it reads local files and runs ffmpeg. It downloads nothing from YouTube or other sites, so no residential IP is needed. Nothing recurs, so no scheduler is involved; run it once per batch of videos. The only connector it needs is Vivu.
Inputs to collect
Ask for anything missing, most important first.
- VIDEO_DIR: the folder with the exported videos. Required.
- The draft product list for each video. Required. A rough name per product is enough ("pink soap dish", "the ESR charger").
- The transcript files. Default: look for an .srt or .vtt next to each video with the same name; otherwise ask whether to run the local speech to text tool.
- WORK_NAME: a short name for the working folder and the Vivu project. Default: the month and "products", for example oct-products.
- Whether to run the camera search for products missing from the list. Default: yes.
Files and state
Keep everything in one working folder:
products-WORK_NAME/
config.json videos, draft product list, Vivu project id, query wording per product
videos.csv file, episode, duration_s, video_id, transcript file
upload/ the videos to index (copies of the final exports)
transcripts/ one .srt or .vtt per video
results/ one JSON per search, without the result page link
sheets/ half second contact sheets inside each window
frames/ full frames the model text was read from
candidates.csv every window Vivu returned, with the verdict and the reason
product_list.csv the list: one row per product
description_block.txt the text the creator pastes into each video's description
state.json steps done, files uploaded, searches run with job ids, windows checked
Run every command from the folder that contains products-WORK_NAME/. A rerun reads state.json first: an uploaded video is not uploaded again, a search with a saved result is not run again, and a window with a verdict in candidates.csv is not checked again.
Step 1: Check the Vivu connector and the setup
Goal: confirm every requirement before spending anything.
- Call vivu_get_account. If the tool does not exist, tell the user to add the Vivu connector in Claude (
https://mcp.vivu.ai/mcp) and stop. If the account does not showcan_create_projects: true, or a later write call fails with "has not granted vivu.write", ask the user to reconnect Vivu and allow write access, then stop until they have. - Run
ffmpeg -versionandffprobe -version, and check that each video has a transcript (or that the speech to text tool runs). - Confirm the Compliance items with the user before anything is uploaded: these are the creator's own videos; anyone else on camera (family, friends, a guest) agreed to be in the published video; and whether any video features children. If one does, upload it only when the creator confirms the guardian consent they hold covers storing it in a private Vivu project (Compliance 3).
Done when vivu_get_account shows can_create_projects: true, both ffmpeg commands print a version, every video has a transcript or a working speech to text tool, and the user has answered the Compliance questions.
Step 2: Measure and price the job
Goal: the videos measured and priced, with the user's approval before anything is uploaded.
- Copy the videos into products-WORK_NAME/upload/ with names that keep only letters, digits, "-" and "_" (VIDEONAME below), so Vivu keeps each name as it is. Vivu rewrites spaces and punctuation in file names.
- Measure each file and write duration_s into videos.csv:
ffprobe -v error -show_entries format=duration -of csv=p=0 products-WORK_NAME/upload/VIDEONAME.mp4
- Call vivu_get_usage and show one table:
| This product list | Plan allowance | Remaining this month | |
|---|---|---|---|
| Index minutes | sum of duration_s / 60 | from vivu_get_usage | from vivu_get_usage |
| Search credits | 5 per listed product, plus 5 for the camera search, plus 5 for each rewording (estimate) | from vivu_get_usage | from vivu_get_usage |
Plan facts: Free is $0 a month with 20 index minutes a month and 50 search credits a month; Premium is $30 a month with 180 index minutes and 500 search credits. A precise search uses 5 credits in total. For example, three 15 minute videos with ten products are 45 index minutes and 55 credits (estimate): more minutes than Free holds, inside Premium.
- If the job does not fit, offer levers in this order: index only the videos the creator is publishing now, then fewer videos per batch across two months, and only then a larger plan. Never drop a video or a product without naming it.
In our test run the 3 videos measured 24.78 minutes. The account used in our test run returns no allowance figures, so the plan table and the user's approval were not exercised in our test run.
Done when every video is in upload/ with a duration_s in videos.csv and the user has approved the minutes and credits.
Step 3: Upload and index
Goal: every video indexed in a private Vivu project.
- Call vivu_list_projects and reuse a project named "Products WORK_NAME" if one exists. Otherwise call vivu_create_project with that name and visibility "private". The default visibility is organization, which shows the project to everyone in the user's Vivu organization, and unreleased videos should stay private.
- Call vivu_open_upload_page with the project ID immediately before uploading. The link expires in 180 seconds and works once, so never post or store it. Give it to the user to open in their own browser and select every file in upload/, or open it in a browser tool that can attach local files. Claude in Chrome accepts at most 10 MB per upload call, and an exported video is usually larger, so most creators will open the link in their own browser or add the files in the Vivu web app. Never split or recompress a video to fit.
- Poll vivu_list_videos about every 30 seconds until every video shows ready. Match each listed file_name to videos.csv and record the video_id; when a name does not match, match by duration_ms against duration_s.
In our test run all 3 videos were ready 14.6 minutes after the upload started; the shorter videos waited in the queue while the longest one indexed. The files went through the upload page with an automated browser, so opening the link in the user's own browser was not exercised in our test run.
Done when every row of videos.csv has a video_id and every video shows ready.
Step 4: Search
Goal: saved candidate windows for every listed product, plus candidate windows for items shown to the camera.
The chain: one speech search per listed product finds where the creator introduces it (said), Step 5 checks those windows against the transcript, the camera search flips from what was said to what was shown and catches items the list forgot, and Step 7 reads the name and model off the box in frames from those windows. fast is not used: it returns whole files with an empty reason, and each video is one file you already know.
| Field | Query | Mode | maximum_results |
|---|---|---|---|
| intro_PRODUCT (one per listed product) | the creator talks about PRODUCT_DESCRIPTION: picks it up or shows it and says what it is or what it is for | precise | 5 |
| unlisted_item (one for the whole project) | the creator shows an item to the camera: holds a product, its box or an accessory up toward the lens, or lifts it out of its box under an overhead camera, so the item fills a large part of the picture | precise | 30 |
PRODUCT_DESCRIPTION is the creator's name for the product plus what it is in plain words ("a drain soap box, a soap dish that lets water drain away"). When two products in the same batch are alike (a phone stand and a laptop stand, measuring cups and a measuring chart), add what tells them apart and name the other one as not counting ("a small folding stand that holds a phone or a tablet upright on a desk; a laptop stand does not count"). maximum_results 5 leaves room for the few stretches where a product comes up again; for the camera search, 30 covers about ten products in each of three videos. Both values are also the recall ceiling, so raise them for longer videos (the limit is 100).
Run vivu_search_videos (project_id, query, mode "precise", maximum_results) for each. It returns a job ID; call vivu_get_search_results until complete is true. Each status call can wait up to 45 seconds, so a pending search is not a stalled one. Save each result to results/FIELD.json without the result page link. Show the result page link only in the live reply: it expires after four hours, so it never goes into the list or the description.
Done when every listed product and the camera search have a saved result file and their job ids are in state.json.
Step 5: Check the speech windows
Goal: each speech window kept or rejected against the transcript, and a rewording for any product whose windows are wrong.
- Read the transcript lines between start_ms and end_ms. Kept: the creator talks about that product. Rejected: the window is about a different product, even one that looks alike. Count rejected windows as false positives and write every window, kept or rejected, into candidates.csv with the reason.
- Copy one line where the creator introduces the product into intro_line, word for word from the transcript. The reason text is a paraphrase and has described products that were not in the window, so it never fills a cell.
- When a product has no kept window, reword its query once as in Step 4 (say what tells it apart from the look-alike) and run it again. Tell the user which wording changed and why.
- A second signal when the transcript is missing or unclear: vivu_get_video_summary with include_segments, start_ms and end_ms around the window. Its section boundaries are rough, so never take a time from it (not exercised in our test run).
Worked example from our test run
The test corpus was 3 public creator videos (24.78 minutes in total): a haul of unbranded household items held up to the camera with listing cards edited in, a talking head unboxing of a branded wireless charger, and a hands-only overhead unboxing of a branded charging dock. Before searching we wrote down every product, when it first appears and what its box says, then gave the searches a draft list that left out the microwave splatter cover and the dock's power adapter on purpose. With the final wordings the speech searches found an intro window for each of the 10 listed products: 13 windows, 0 false. The first wordings had 2 false windows: the phone stand query also returned the laptop stand from the same haul, and the measuring cups query returned only a window about other items, with a reason describing measuring cups that were not there. Each of those queries now uses the wording we settled on after 1 rewording on the same corpus, naming the look-alike as not counting. One product was never named aloud ("the next thing I got is this"), and its search still found the window; the name came from the listing card on screen.
Done when every speech window has a verdict in candidates.csv and every listed product has a kept window with an intro_line, or is marked "not found" after one rewording.
Step 6: Check the camera windows and find what the list missed
Goal: each camera window kept or rejected from frames, matched to a listed product or flagged as a new item.
- For each window, make a strip of six frames across it:
ffmpeg -v error -y -ss START -t DURATION -i products-WORK_NAME/upload/VIDEONAME.mp4 -vf "fps=6/DURATION,scale=320:-1,tile=6x1" -frames:v 1 products-WORK_NAME/sheets/VIDEONAME_START_strip.png
START is start_ms / 1000 and DURATION is (end_ms - start_ms) / 1000, both in seconds. For a window longer than about 60 seconds, make a half second sheet of the whole window instead, because a short appearance falls between six tiles:
ffmpeg -v error -y -ss START -t 32 -i products-WORK_NAME/upload/VIDEONAME.mp4 -vf "fps=2,scale=256:-1,tile=8x8" -frames:v 1 products-WORK_NAME/sheets/VIDEONAME_START_sheet.png
One sheet covers 32 seconds; tile k is at START plus k/2 seconds. Repeat from START plus 32 until the window is covered. 2. Kept: the frames show an item, its box or an accessory held or lifted toward the camera. Rejected: shipping bags and mailers, or an item that is small in a talking head shot. Count rejected windows as false positives. 3. Match each kept window to a listed product by looking at the frames, not by the reason (the reason once called a charger base a power adapter). Every item that matches nothing on the list goes to the user as a NEW row candidate with its frame: a product the list forgot, an accessory from the box, or a prop such as the phone used to demo a charger. The creator decides which ones belong in the description. 4. An empty camera search, or no window for an item, does not prove the item is not in the video. Tell the user that the list still depends on their draft.
In our test run the camera search returned 23 windows: 20 real and 3 false (shipping mailers and a small box beside the creator's face). It brought back the microwave splatter cover we had left off the list. It missed the power adapter we had also left off: the adapter was only on the last tiles of a wide window whose reason described the box, which is why long windows get a full half second sheet. It also turned up a thank-you card from a box and a second charger box from the same brand, which the creator would sort out by hand.
Done when every camera window has a verdict in candidates.csv and every NEW item has been shown to the user with its frame.
Step 7: Read the model text and set first seen
Goal: for each product, the brand and model text read from a full frame, and the time it first appears.
- Pick the kept window (speech or camera) where the box or the product label faces the camera, and extract a full frame from the middle of that stretch:
ffmpeg -v error -y -ss SECONDS -i products-WORK_NAME/upload/VIDEONAME.mp4 -frames:v 1 -q:v 3 products-WORK_NAME/frames/VIDEONAME_SECONDS.png
- Copy only the brand and model words printed on the box or the product, exactly as written. Leave the cell blank when nothing readable is printed, and say why ("label too small to read", "plain bag, no brand"). A name on a listing card the editor added is on-screen text, not packaging; use it for the product name, not as a model. Text in the background (a fridge maker's logo behind a fridge magnet) is not the product's. Never complete a word from the reason text, the captions or memory: captions misspell brands, and a guessed model sends viewers to the wrong product.
- first_seen is the earliest start_ms of any kept window for that product, from either search, written as MM:SS. It can still be late: the creator may show the box in the opening lines before any window starts. Make a half second sheet of the 32 seconds before first_seen (Step 6 command, START = first_seen minus 32) and move first_seen back if the product is already being shown; if you cannot tell, mark first_seen UNCERTAIN.
In our test run the model text we read from frames matched what we had written down before searching: the ESR and Nomad boxes and the plain laptop stand box were read as printed (glare hid part of a word on the Nomad box), the power adapters' labels were too small to read and stayed blank, and the haul items' bags carried no brand at all. For one product the earliest window started after the creator had already held its box up in the intro, so the chapter time would have been late; the sheet before first_seen was not exercised in our test run. For the measuring cups the camera window started earlier than the speech window and set first_seen.
Done when every product row has a frame_path, a model_text_from_frame value or a reason it is blank, and a first_seen.
Step 8: Write the list and the description block
Goal: product_list.csv and description_block.txt that the creator has checked.
- Show the user one sample row and the field mapping, and wait for a yes before writing the rest:
product,episode,source_file,first_seen_mmss,model_text_from_frame,intro_line_from_transcript,frame_path,chapter_line,buy_link,found_by,status
3-in-1 wireless charger,EP02,EP02_KBAVdn6zuWM.mp4,00:49,ESR HaloLock 3-IN-1 WIRELESS CHARGER with CryoBoost,"i'll be looking at the new esr31 headlock wireless charger with cryoboost",frames/EP02_KBAVdn6zuWM_52.png,00:49 ESR HaloLock 3-in-1 Wireless Charger with CryoBoost,,speech search + camera search,UNCERTAIN first_seen
| Field | Source | If unavailable |
|---|---|---|
| product | the creator's draft list, or the listing card or box for a NEW item | none |
| episode, source_file | videos.csv | none |
| first_seen_mmss | earliest kept window, checked on the sheet (Step 7) | UNCERTAIN |
| model_text_from_frame | full frame (Step 7) | blank with the reason |
| intro_line_from_transcript | transcript, word for word (Step 5) | NOT VERIFIED without a transcript |
| frame_path | the frame the model text was read from | blank |
| chapter_line | "MM:SS Product name" from first_seen and the model text or product name | none |
| buy_link | left empty for the creator | stays empty |
| found_by | speech search, camera search, or both | none |
| status | checked, NEW (confirm with creator), UNCERTAIN, or not found | none |
- Write product_list.csv with one row per product, including NEW items the creator kept and listed products marked "not found".
- Write description_block.txt: for each video, a "Products in this video" list with LINK placeholders and a chapters list. YouTube chapters start at 00:00, need at least three entries and each must run at least 10 seconds, so merge a product that appears in the first seconds into the 00:00 line and leave chapters out for a video with too few products. Add one line reminding the creator to add their own affiliate or gifted product disclosure; the skill does not write it.
- Add a short summary for the user: products found, NEW items, rows marked UNCERTAIN or not found, and per search how many windows Vivu returned and how many were rejected as false positives.
- The creator fills in buy_link and pastes the block into each video's description themselves. If they ask Claude to post it, put it in a shared doc or edit the video description through another connector, name the destination, show the full text, and wait for explicit approval.
In our test run the list has a row for each listed product plus the recovered splatter cover marked NEW, and the description block left chapters out for the video with a single product, since YouTube needs at least three. The user's approval of the sample row was not exercised in our test run, and nothing was posted.
Done when product_list.csv has a row for every listed product and every kept NEW item, description_block.txt has a section per video, and the user has approved the sample row.
Compliance
- Use only the creator's own videos, from their own files. Confirm this in Step 1; the skill does not import platform links or other channels' videos.
- Family, friends or guests on camera agreed to be in the published video; this skill only reads it for a local list. It reads speech and printed text only and does not identify anyone by face, or any brand by its logo.
- If a video features children, upload it only when the creator confirms the guardian consent they hold covers storing it in a private Vivu project; otherwise build that video's rows from the transcript alone, marked NOT VERIFIED for model text.
- Affiliate links, gifted products and sponsorships are disclosed by the creator under their platform's rules. The skill leaves the disclosure line for the creator to write.
- The videos stay in the user's Vivu project until the user deletes them. Create the project as private. Delete a project or video only when the user asks, and confirm first.
- Posting the description or editing the video acts as the creator; the skill leaves that to them or asks first (Step 8).
Known failure modes
| Symptom | Cause | Fix |
|---|---|---|
| (observed) the phone stand search also returns the laptop stand from the same haul | two look-alike products in one batch | reword once, naming what tells them apart and the look-alike as not counting (Step 4) |
| (observed) the reason says "The creator unboxes and shows a set of 4-piece measuring cups, explaining their measurements and how they will make her baking easier." but the window is about other items | the reason text paraphrases and can describe what the query asked for | judge every speech window from the transcript (Step 5) |
| (observed) a product left off the list shows up only on the last tiles of a long camera window | wide windows cover several items and the reason names one | make a half second sheet of any window longer than about a minute (Step 6) |
| (observed) the reason says "The creator takes the power adapter out of its packaging and holds it up close to the camera lens." while the frames show the charger itself | the reason misnames the item | match camera windows to products from frames only |
| (observed) captions write the brand as "esr31 headlock wireless charger" | auto captions mishear brand names | read the model from the box frame; quote captions as they are only in intro_line |
| (observed) the earliest window for a product starts after its box was already shown in the intro | windows start where the search places the introduction, not at the first appearance | check the stretch before first_seen on a half second sheet, or mark it UNCERTAIN |
| (observed) shipping mailers come back from the camera search | a held up bag looks like a held up product | reject them in Step 6 |
| a small label or a reflective box cannot be read | low resolution frames and glare | leave the cell blank with the reason; ask the creator for the model |
| an item never held up and never named is missing from the list | both searches need a mention or a clear showing | an empty result does not prove the item is absent; ask the creator to check the list |
| upload page asks to sign in or shows an error | the one time upload link expires after 180 seconds | request a new link right before opening it |
| a file is rejected by the browser upload tool | Claude in Chrome accepts at most 10 MB per upload call | the user opens the upload link in their own browser or adds the file in the Vivu web app |
| "has not granted vivu.write" | Vivu connected read only | the user reconnects Vivu with write access |