Warranty serial sheet from install videos

---
name: install-warranty-serial-sheet
description: "Read model and serial numbers off equipment nameplates in a week of install job videos with Vivu and write a warranty registration sheet. Use when serials are missing from work orders."
---

Warranty serial sheet from install job videos

This skill takes a folder of install job videos (the clips technicians shoot on their phones when a job is done, one or more per work order, with the work order number in the file name) and returns a warranty registration sheet: one row per unit, with the work order, the file, the minute and second where the nameplate is on screen, the model and serial number read from a full frame, a saved frame of the nameplate, and an empty column for the warranty admin to tick after checking. Jobs where no nameplate can be found go on a separate list, so someone asks the technician for a photo instead of guessing. Claude measures the videos, prices the indexing against the user's Vivu plan, indexes them in a private Vivu project, runs one cheap file level search and one precise search for nameplate close ups, extracts frames every half second inside each window, reads the plate from the sharpest frame, scans any job the search missed, and writes warranty_sheet.csv.

The value is in a number that exists only on a sticker. Work order notes often leave the serial out, the technician rarely reads it aloud (and a serial read aloud is easy to get one digit wrong), and the sticker is on screen for a few seconds of a two minute clip, so finding it means scrubbing every video by hand. Vivu finds the stretch where a plate fills the frame; the frames, not Vivu, decide what the number is. A serial that cannot be read with certainty goes into the sheet as NOT LEGIBLE, never as a best guess, because a wrong serial on a warranty claim is worse than a blank one.

When to use

Use when a warranty admin, ops coordinator or service manager says "pull the serial numbers from this week's install videos", "we need model and serial for every unit we put in for warranty registration", "the techs filmed the nameplates, get me the numbers", or "which jobs have no nameplate in the video". For one job, open the video and pause on the plate yourself, or ask Vivu directly. For defects or progress on site, use an inspection or site walk skill instead. This skill does not judge the technicians' work, does not check install quality, and does not submit anything to a manufacturer's warranty portal; the admin does that from the checked sheet.

Working principles

1. Report measured numbers, not estimates. When a number is an estimate, say so.
2. Vivu's results are candidates. A row is filled only after Claude has looked at the full frame; a model or serial is written only when every character is readable on that frame. Anything else is NOT LEGIBLE or partly legible, with the readable part only.
3. Stop and tell the user when a required capability or file is missing (no ffmpeg, no write access in Vivu, no work order number in a file name). Do not guess around it.
4. Ask the user before anything that is expensive to redo or that acts on their behalf: the indexing cost before upload, and the sample rows before the full sheet.
5. Read equipment, not people. People, house numbers and license plates that show up in a frame never go into the sheet, and the sheet has no column about the technician.

What you need before starting

Check each item at the start of the run and tell the user plainly what is missing.

The skill needs a shell and local files, so it runs in Claude Code on the user's computer (terminal or the Code tab of Claude Desktop). It downloads nothing from YouTube or anywhere else, so no residential IP is needed. Nothing is scheduled and nothing is written outside the working folder.

Inputs to collect

Ask for anything missing, most important first.

1. The folder with this batch of job videos (JOBS_FOLDER). Required.
2. How the work order number appears in the file names (for example WO-12345 at the start). Default: Claude proposes a pattern from the file names and the user confirms.
3. Which equipment types to expect (condenser, furnace, coil, water heater, inverter, battery). Default: any; the type is read from the plate.
4. The Vivu project name. Default: "Install jobs WEEK", private, where WEEK is the week's start date.

Files and state

Keep everything in one working folder next to the videos:

warranty-serials/
  jobs.csv            file, work order, minutes, video id
  results/            raw search results, one JSON file per search
  frames/             half second sheets and the full frames each serial was read from
  warranty_sheet.csv  one row per unit found, with the read status and an empty human_check column
  no_plate_jobs.txt   work orders where no nameplate was found, for the admin to chase
  state.json          uploaded files and video ids, searches run with job ids, every window with its verdict, rows written

state.json is updated after every step. A rerun reads it first: files already uploaded are not uploaded again, searches already run are not rerun, and windows already read keep their verdicts, so an interrupted run resumes where it stopped. A video that is already in the project from an earlier week is skipped by video id, so the same unit is not written twice.

Step 1: Check the Vivu connector and the setup

Goal: every row of What you need is confirmed before anything is uploaded.

1. Call vivu_get_account. If the tool is missing, tell the user to add the Vivu connector in Claude (https://mcp.vivu.ai/mcp) and stop. If can_create_projects is not true, or a write call later fails with "has not granted vivu.write", ask the user to reconnect Vivu with write access and stop until they have.
2. Run ffmpeg -version and ffprobe -version.
3. List JOBS_FOLDER. Propose the work order pattern from the file names and list any file it does not match.
4. Create the working folders; ffmpeg does not create an output folder:

mkdir -p warranty-serials/results warranty-serials/frames

Run every later command from inside warranty-serials/ (cd warranty-serials), with JOBS_FOLDER given as a full path.

Done when vivu_get_account shows can_create_projects: true, ffmpeg and ffprobe print versions, the user has confirmed the work order pattern, and the working folders exist.

Step 2: Price the indexing and get approval

Goal: the user sees the cost before anything is uploaded.

1. Ask Compliance items 1 and 2 first.
2. Measure each video and sum the minutes. ffprobe takes one input file per call, so run it once per file (VIDEO_FILE is a file in JOBS_FOLDER):

ffprobe -v error -show_entries format=duration -of csv=p=0 JOBS_FOLDER/VIDEO_FILE

3. Call vivu_get_usage for the plan and what remains this month.
4. Estimate search credits: one fast search and one precise search per batch; a fast search uses 1 credit and a precise search uses 5 credits in total. Label the total as an estimate.
5. Show one table and wait for approval:

For reference, the Free plan has 20 index minutes a month and 50 search credits a month; Premium is $30 a month with 180 index minutes and 500 search credits. As an estimate, 25 jobs a week at two minutes each is about 50 index minutes a week, which fits Premium for three weeks of a month, not four. If a batch does not fit, offer these levers in order: upload only jobs whose work order is missing a serial, or split the batch across two months, and only then a larger plan. Never drop a job the user asked for without saying so.

In our test run the account was an admin account whose vivu_get_usage shows no remaining allowance, so the comparison against a real plan and the approval were not exercised in our test run.

Done when the user has approved the minutes and the credit estimate.

Step 3: Upload and index

Goal: every job video is ready in a private Vivu project.

1. Call vivu_list_projects and reuse the project named in the inputs if it exists. Otherwise call vivu_create_project with that name and visibility "private". Job videos show customers' homes; the default visibility is the whole organization.
2. Call vivu_open_upload_page with the project ID right before the upload. The link expires in 180 seconds and is a sign in link, so never paste it into a message or file. Give it to the user to open in their own browser and choose the files, or attach them with a browser tool that can upload local files. Claude in Chrome accepts at most 10 MB per upload call, and a two minute phone clip is often larger; the user adds those in the Vivu web app. Never split or recompress a video to fit.
3. Poll vivu_list_videos about every 30 seconds until every file shows ready. Match each video back to jobs.csv by file name; Vivu turns spaces and punctuation in names into "_", so compare names with those characters replaced. Record the video IDs in state.json and jobs.csv.

In our test run the files went up through a script, not through a user's browser or Claude in Chrome; that upload path was not exercised in our test run.

Done when vivu_list_videos shows every file in jobs.csv as ready.

Step 4: Find the nameplate moments

Goal: a list of windows where a nameplate fills the frame, plus a list of jobs that have none.

Two searches cover the whole batch, because one search covers the whole project:

1. Run plate_files with vivu_search_videos (project_id, query, mode "fast", maximum_results 30). A fast search returns whole files with an empty reason and no times, in ranked order; it is a cheap list of which jobs are worth reading, not evidence of a plate. Save it as results/plate_files.json.
2. Run nameplate with vivu_search_videos (project_id, query, mode "precise", maximum_results 30). 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 it as results/nameplate.json. Show the result page link in the live reply only; it expires after four hours, so it never goes into the sheet or any file.
3. maximum_results is also the ceiling on what comes back. Set it above the number of jobs in the batch, with room for jobs that film more than one unit (30 for a week of 25 jobs; for more than about 25 jobs, use the number of jobs plus a third, up to 100); when a list stops at exactly that number, raise it and rerun.
4. Write each precise window into state.json as a candidate, and list the jobs with no precise window. Those go to Step 6.

Why this chain: the precise search turns a two minute clip into a window of a few seconds around the plate, the half second frames in Step 5 turn the window into a sharp frame that a person can read, and the fast list plus the scan in Step 6 catch a job the precise search left out, so a missing serial is chased instead of silently dropped. A spoken serial ("serial ends in 4547") is not used, because a number read aloud is easy to get one digit wrong and the sticker is the record; the test videos had no sound, so no speech search was run.

Done when results/nameplate.json and results/plate_files.json exist and every precise window is in state.json.

Step 5: Check each window and read the plate

Goal: every window is confirmed or rejected against frames, and every confirmed plate has a model and serial read from a full frame or marked as not legible.

Vivu returns a time range that contains the plate, not the exact seconds, and the reason text describes the plate in general words ("clearly displaying the model and serial number") without the numbers. Finding a close up by how it looks is a weak capability in general, so frames decide, never the search alone.

1. Make a sheet of one frame every half second across the window (START is start_ms / 1000, DURATION is (end_ms - start_ms) / 1000; WO is the work order, HIT is h plus the window's number; the 8x6 grid holds 24 seconds, so for a longer window raise the second number):

ffmpeg -v error -ss START -t DURATION -i JOBS_FOLDER/VIDEO_FILE -vf "fps=2,scale=320:-2,tile=8x6" -frames:v 1 frames/WO_HIT_sheet.png

Keep the quotes around the filter. Look at the sheet. Reject the window if no cell shows a plate or serial sticker close enough to read (a label across the room, an app screen listing serials, a title card with example numbers). Windows usually start and end a second or two outside the plate, so the first and last cells often show something else. 2. On the sheet, pick the cell where the plate is sharpest, flattest and least covered by glare, a finger or a pen. Extract that moment at full resolution (SECONDS is the window start plus half the cell's index):

ffmpeg -v error -ss SECONDS -i JOBS_FOLDER/VIDEO_FILE -frames:v 1 -q:v 3 frames/WO_HIT_read.png

3. Read the plate from that full frame. Copy the model and serial exactly as printed, spaces and dashes included. Write a field only when every character is clearly readable. When a stain, glare, a finger or blur hides any character, write "partly legible" with ? for each unreadable character, try the neighboring cells once, and if it is still not certain, leave the gap for the admin. Never fill a gap from the model number's usual pattern; a guessed serial on a warranty claim is worse than a blank.
4. When the frame shows several units (two microinverters side by side, a condenser and a coil), write one row per unit.
5. Rejected windows stay in results/ and state.json with the reason; they are counted, not dropped silently.

Worked example from our test run

In our test run we used 10 public videos, 11.39 minutes in total: short clips cut from HVAC, water heater and microinverter videos on manufacturer, parts supplier and installer channels, renamed like work orders (WO-NUMBER.mp4), with the sound removed so only the picture could lead the search. They covered a handheld phone clip of a condenser in low sun, a furnace plate under a blue door light, a stained water heater label with glare, plate photos inset over a technician, and two microinverters with small barcode stickers. The distractors were a water heater label pointed at from across a dim basement, labels small in the background behind a presenter, title cards showing serial number formats with no equipment, and element replacement close ups. Before searching we wrote down every nameplate moment and copied each model and serial from a full frame. From the upload to all 10 videos ready took 9.6 minutes, most of it with a single file waiting in the queue.

The fast search returned all 10 files, ranked: it put the title card job above a real plate job, so it orders the batch but does not say which jobs have a plate. The precise nameplate search, first wording on this corpus, returned 9 windows: 9 real, 0 false and 1 missed out of 10 nameplate moments we wrote down. The miss was an end card with several small plate photos side by side, the same plates the other windows of that job had already found, so every job with a plate got at least a window. None of the distractors came back. Windows had a median of 14 seconds and often began or ended on another scene (plants, an attic, a title card, an app screen listing serial numbers), which is why the half second sheet, not the window, decides where the plate is.

Reading was done from full frames by a separate reader that had not seen our notes. Every serial it wrote in full matched what we had copied before searching (the plate photos inset over the technician carry a sample serial printed by the manufacturer, and it was copied as printed). Where a pen tip covered a character, it wrote the serial as partly legible, and on a neighboring frame without the pen we read the full number; where a rust stain covered the start of a water heater's model and serial, both stayed partly legible, which is the right answer because the characters are not visible. The model lines on the furnace and coil plate photos were too blurred to finish. Nothing was written with a wrong character. The reason text never gave a number. In our test the clips were short and mostly how to footage; real phone clips with a moving camera for the whole job, rain or night lighting, and plates at an angle were not exercised in our test run.

Done when every window in state.json has a verdict and every confirmed plate has a read frame in frames/.

Step 6: Scan the jobs with no plate window

Goal: every job without a confirmed plate is either found by a scan or listed in no_plate_jobs.txt.

1. For each job with no confirmed window from Step 5, in the order the fast search ranked them (the order only decides what is looked at first; every such job is scanned), make a sheet of the whole clip at one frame per second (the 10x10 grid holds 100 seconds; raise the second number for longer clips):

ffmpeg -v error -i JOBS_FOLDER/VIDEO_FILE -vf "fps=1,scale=240:-2,tile=10x10" -frames:v 1 frames/WO_scan.png

2. If a cell shows a readable plate, go back to Step 5 with a window around that second. Otherwise add the work order to no_plate_jobs.txt with what the clip shows instead (for example "unit filmed from across the room, label not readable").
3. Tell the user which jobs are on the list. An empty search result does not prove the video has no plate; the scan is what decides.

In our test run every job without a precise window was scanned this way; none of them had a readable plate, and all went on the list with the reason shown in their scan.

Done when every job in jobs.csv has a confirmed plate row or a line in no_plate_jobs.txt.

Step 7: Assemble the sheet and confirm the sample

Goal: one table the warranty admin can check and enter into each manufacturer's warranty portal.

1. Build one row per unit:

work_order,source_file,mm_ss,equipment_type,model,serial,read_status,frame_path,human_check
WO-3102,WO-3102.mp4,00:34,condensing unit,HS29-048-9Y,5898E 48224,read,frames/WO-3102_h1_read.png,
WO-3104,WO-3104.mp4,00:10,water heater,partly legible: ??V40D D,partly legible: ?? 1001F02107,partly legible,frames/WO-3104_h9_read.png,

2. Field mapping:

3. Show two or three sample rows, the mapping and no_plate_jobs.txt, and wait for a yes before writing the full table. Say which parts are Claude's reading: every model and serial is copied by Claude from a frame, so the admin opens frame_path and confirms each one before it goes to a manufacturer; equipment_type is read from the plate's wording and may be blank.
4. Write warranty_sheet.csv and no_plate_jobs.txt, and give the user the counts: units read, partly legible, not legible, and jobs with no plate.

In our test run the sheet and the no plate list were written from the checked windows and the scans; the user's approval of the sample rows was not exercised in our test run.

Done when warranty_sheet.csv and no_plate_jobs.txt exist and the user has approved the sample rows.

Compliance

1. Use only your company's own job videos, filmed by your technicians at your customers' sites. Ask before Step 2 whether your customer agreements and company policy allow uploading these videos to a third party service.
2. Job videos show the inside of customers' homes and sometimes people, house numbers or license plates. Ask before Step 3 and create the Vivu project as private (the default visibility is the whole organization). None of that goes into the sheet; only equipment fields do. The videos stay in the user's Vivu project until the user deletes them; the skill never calls vivu_delete_video or vivu_delete_project unless the user asks, and confirms first.
3. The sheet is for warranty registration. It does not score technicians, check install quality or judge whether a job was done right.
4. No face, voice or identity recognition. Vivu only finds when a plate is on screen; the numbers are read by Claude from frames extracted by the user's own ffmpeg from their own files.
5. The skill does not submit anything to a manufacturer. The admin enters the checked rows.

Known failure modes