How to Give Claude Code a Screen Recording (3 Methods, Ranked)

Claude Code can't open an MP4 — it reads text and still images, not video. To give Claude Code a screen recording, you convert the video into frames plus a transcript it can read. Three methods do this: extract frames by hand, run a video MCP server, or paste a Clipy link the agent reads as a document. Ranked below.

Disclosure: Clipy is our product. We've kept the comparisons factual and cite sources for competitor claims — tell us if anything is stale.

Why you can't just drop a .mov into Claude Code

Point Claude Code at a screen recording and nothing useful happens. Read a .mov and you get a binary-file error; there's an open feature request to support video input precisely because it doesn't yet. The underlying models accept text and still images, not an hour-long video stream. So every working method below does the same thing under the hood: it turns your recording into frames the model can see and a transcript the model can read, then hands those to the agent.

The methods differ only in who does that translation and how much work it is for you. That's the whole ranking. We'll go worst-to-best.

Here's the shape at a glance:

Method 1 (baseline): extract frames and a transcript by hand

This is the "no new tools" path. You already have the recording, so you slice it yourself and paste the pieces into Claude Code.

Pull a frame every couple of seconds with ffmpeg:

# one frame every 2 seconds into ./frames
ffmpeg -i bug.mov -vf fps=1/2 frames/frame_%03d.png

# grab a still at an exact moment you care about (0:47)
ffmpeg -ss 00:00:47 -i bug.mov -frames:v 1 frames/click.png

Then transcribe the audio locally with Whisper so the agent gets the narration:

pip install -U openai-whisper
whisper bug.mov --model small --output_format txt

Now drag the frames into Claude Code and paste the transcript alongside a prompt: "These frames are from a screen recording of a bug. Transcript attached. The menu at frame_012 renders behind the modal — find and fix the CSS."

Verdict — the painful baseline. It works with zero services and everything stays on your machine. But you do the labor every single time, you guess which frames matter (extract too few and you miss the click; too many and you burn tokens on near-duplicate stills), and the frames carry no pointer data — the agent can't tell which of three identical buttons the cursor was on. Fine for a one-off. Miserable as a habit. Every other method exists to delete this work.

Method 2: give Claude Code a video MCP server

The Model Context Protocol lets Claude Code call external tools directly. A video MCP server does Method 1's frame-extraction and transcription on demand — you register it once, and from then on the agent pulls what it needs. Claude Code supports two transports here: a local stdio server it launches over npx, and a remote HTTP server it connects to over the network (Claude Code MCP docs).

Video Vision MCP — a local "watch this file" server

Video Vision MCP is open-source (MIT) and fully local. It runs frame extraction through ffmpeg with scene detection — grabbing the moments that change instead of a fixed interval — and transcribes with a local Whisper model, burning a visible timestamp into every frame. Add it to Claude Code:

claude mcp add video-vision -- npx -y @oamaestro/video-vision-mcp

Then point it at a file or a URL: "Use video-vision to watch ./bug.mov and tell me why the dropdown clips." Nothing leaves your machine, which is the real reason to reach for it. The trade-off: it analyzes video you already have — it doesn't record anything, and it has no notion of where the cursor clicked. You're still responsible for capturing the recording.

Jam MCP — browser capture with dev telemetry

Jam is a browser bug-capture tool with a hosted, remote MCP. Its genuine strength is developer telemetry: when you record a browser session, Jam captures console logs, network requests, and user events alongside the video, and its MCP hands all of that to your agent. If your fix hinges on a 500 response body or a console stack trace, that context is gold and worth crediting. Add the remote server to Claude Code:

claude mcp add Jam https://mcp.jam.dev/mcp -t http -s user

Then paste a Jam link into the chat and describe the bug. The limits are honest ones: Jam is browser-only (Chrome extension), it's a hosted service with paid team tiers, and it can't capture a native-app or desktop bug that never touches a browser tab.

Verdict — a real step up, with a setup tax. MCP servers remove the per-recording manual labor of Method 1, and Jam adds context no still frame carries. But you're installing and maintaining a server, the local option still needs you to capture the video some other way, and neither gives a teammate something to watch — an MCP tool call isn't a share link. For a full head-to-head on these, see our MCP screen recorders compared breakdown.

Method 3 (recommended): paste a Clipy link, let the agent read the .md

The other two methods make the agent (or you) translate video at consumption time. Clipy does it once, at record time, server-side — so the thing you hand Claude Code is already text and images. You record the screen, you get a normal share link, and that link doubles as a machine-readable document. No file to slice, no frames to guess, no ffmpeg.

How it works

Every Clipy watch URL has a machine-readable twin: append .md (or .json, or ?format=md).

https://clipy.online/video/abc123xyz        → the page a human watches
https://clipy.online/video/abc123xyz.md      → the document an agent reads

That .md isn't a raw transcript dump. It's a structured recording document containing:

• an AI summary (TL;DR + key points) and an action-items / fix checklist,
• key moments — each with an extracted frame image, and for Mac-app and Chrome-extension tab recordings, the click coordinate as x/y fractions of the frame (with a red-and-white marker burned into the frame at that spot) plus a "move this → to here" motion target on drags,
• the full timestamped transcript.

Public recordings need no auth — the agent just fetches the URL. (For Mac recordings, key moments also carry the clicked element's Accessibility role and label — e.g. AXButton "Checkout" — not just a pixel.) It does not capture console or network logs; that's Jam's lane, and we're not claiming otherwise. The full contract behind this format is written up in what an agent-readable screen recording is.

Set it up once (HowTo)

Step 1 — record. Capture the bug or the walkthrough with the free Clipy screen recorder (browser, Chrome extension, or the native Mac app). Stop, and you get a share link in under two seconds.

Step 2 — teach Claude Code the convention. Install the Clipy agent skill so the agent knows any clipy.online/video/<id> link is fetchable as .md. It's two lines:

mkdir -p ~/.claude/skills/watch-clipy-recording
curl -fsSL -o ~/.claude/skills/watch-clipy-recording/SKILL.md \
  https://clipy.online/skills/watch-clipy-recording/SKILL.md

That's it — no MCP server, no API key for public recordings. (Codex users write to ~/.codex/skills/… instead.)

Step 3 — paste the link with your instructions. In Claude Code:

Watch https://clipy.online/video/abc123xyz and fix the bugs I point out.

Step 4 — let it work. The agent fetches abc123xyz.md, waits and re-fetches if the recording is still processing, reads the summary + key-moment frames + transcript, and enumerates the issues before touching code.

What it looks like when it works: a z-index bug from a link

Say you recorded 40 seconds showing a dropdown menu that disappears behind the checkout modal, narrating "watch — when I open this menu it hides behind the popup." You paste the link. The agent fetches the .md and reads something like:

## Summary
User reports a dropdown menu rendering behind the checkout modal.

## Fix checklist
- Dropdown menu is occluded by the modal overlay when both are open.

## Key moments
Cursor telemetry: PRESENT
### 0:18 — clicks the account menu; menu opens behind the modal
frame: https://cdn.clipy.online/key-moments/abc123xyz/18000.jpg
click: 63% from left, 22% from top

## Transcript
[0:16] watch — when I open this menu it hides behind the popup

Now the agent has what it needs without you narrating it a second time: the frame shows the menu clipped behind the overlay, the coordinate pinpoints which control was clicked (the account menu, not one of the other buttons), and the transcript confirms intent. From there it does what a good engineer does — greps for the modal's z-index and stacking context, finds the overlay creating a new stacking context above the menu, and proposes the fix (lift the dropdown's stacking context or portal it above the modal). You reviewed a diff instead of writing a bug report.

Private recordings and library search — the MCP option

The skill covers public links. For private recordings, authenticated inline frames, or searching your whole library, add the Clipy MCP server with a free API key:

claude mcp add --scope user clipy --env CLIPY_API_KEY=clipy_sk_live_xxx -- npx -y @clipy/mcp

Mint the key at clipy.online/settings/api-keys. The server is read-only and gives the agent tools like search_recordings, get_agent_context (a one-call bundle of summary + action items + key-moment frames + transcript), get_key_moments (frames returned inline as images), and wait_for_artifacts (polls until transcript/summary/key-moments are ready). Full details and the tool list live on the Clipy for AI Agents page.

Verdict — the least work per recording. The frames, coordinates, transcript, and summary are computed once when you hit Stop, so both a human teammate and the agent consume the same link. No file handling, no per-recording extraction, no per-agent server for public clips — and it's free forever with no watermark. That's why it tops the ranking.

Which method should you actually use?

• You have one video sitting on disk and can't send it anywhere → Method 1 by hand, or Method 2 with Video Vision MCP for less babysitting. Fully local.
• You're filing browser bugs and need console/network logs → Method 2 with Jam. That telemetry is real and Clipy doesn't have it.
• You want one link a teammate watches and an agent fixes, across browser and native apps, for free → Method 3, Clipy. Record once, paste the link, done.

Most day-to-day "here's the bug, go fix it" loops land on Method 3 because the translation work is already done by the time the link exists. Start there and drop to Method 2 when you specifically need Jam's dev telemetry.

FAQ

Can Claude Code read a video file directly?

Not today. Reading a .mov or .mp4 returns a binary-file error, and native video input is an open feature request. You give Claude Code a screen recording by converting it to frames and a transcript first — by hand, via a video MCP server, or via a Clipy link that's already in that form.

How do I give Claude Code video context without pasting screenshots?

Install the Clipy agent skill, then paste a clipy.online/video/<id> link into Claude Code. The agent fetches the .md twin of that link, which already contains the key-moment frames, click coordinates, and full transcript — no manual screenshots.

Do I need an MCP server to make Claude Code watch a video?

No, for public recordings. The Clipy skill teaches the agent to fetch any Clipy link as a .md document with no MCP at all. You only need the Clipy MCP server (npx -y @clipy/mcp) for private recordings, authenticated inline frames, or library search.

What's the difference between Jam MCP and Clipy for this?

Jam is browser-only and its MCP hands the agent console logs and network requests — great for browser bug repros. Clipy records anywhere (browser, extension, Mac app), publishes each recording as an agent-readable link, and gives click coordinates and frames but not console/network logs. Different jobs; see our MCP comparison.

Is giving Claude Code a screen recording free?

Method 1 (ffmpeg + Whisper) is free and local. Video Vision MCP is free and open-source. Clipy's recorder, share links, transcripts, summaries, key moments, .md documents, and MCP server are free with no watermark. Jam has a free tier with paid team plans.