Cursor's Agent and Chat can't watch a raw video file, so pasting an MP4 does nothing. To give Cursor video context, record the bug with Clipy and paste the share link — a clipy.online/video/<id> URL that is also fetchable as Markdown. Cursor reads the transcript, the key-moment frames, and the click coordinates, then plans and writes the fix.

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

Why "just paste the video" doesn't work in Cursor

Try dragging a screen recording into Cursor's Chat or Agent and nothing useful happens. Cursor has no native path to accept video as input — it is an open feature request on the Cursor forum, not a shipped capability as of July 2026. So the "record the bug and hand it to the AI" instinct hits a wall on the first step.

The fix isn't to wait for Cursor to learn to watch MP4s. It's to stop shipping the agent a video at all. What Cursor is good at is reading text and structured context. So the move is to turn the recording into text-plus-frames before it reaches Cursor, and hand over a single link that resolves to that.

That is what "cursor video context" means in practice: not a media file the model has to decode, but a machine-readable document the model can read the way it reads a file in your repo.

Every Clipy recording has a public watch page at https://clipy.online/video/<id>. The part that matters for Cursor: append .md (or ?format=md) to that same URL and you get a Markdown document instead of a web page. That document contains:

  • The AI summary and action items — what the recording is about, distilled.
  • The full timestamped transcript — everything you narrated while reproducing the bug.
  • Key moments — extracted frame images at the moments that matter, with click coordinates (x/y as fractions of the frame) so the agent knows exactly where you pointed.
  • On Mac-app and Chrome-extension recordings, the element you clicked — the macOS Accessibility role and visible label (e.g. AXButton "Save draft"), not just a pixel.

So instead of typing "the modal doesn't close when I click the X in the corner," you record yourself hitting the X, and Cursor reads back the exact click target, the surrounding UI state as a frame, and your spoken description — all from one link. Record it once; humans watch the video, and the agent reads the document.

One honest boundary: the Clipy document does not include browser console logs or network request/response payloads. It's the visual + spoken + click-target record of what happened, not a devtools trace. If your bug is purely a silent 500 with no visible symptom, a screen recording won't surface the stack trace — pair it with your server logs. For anything with a visible or narratable symptom, the recording carries the context Cursor was missing.

Setup: two ways to connect Clipy to Cursor

There are two paths. Pick based on whether your recordings are public or private.

For a one-off public bug link, you don't need to install anything. The convention is documented as the Clipy agent skill: any clipy.online/video/<id> link is fetchable as .md, no MCP and no API key. Paste the link into Cursor's Agent and tell it to fetch the Markdown version:

Fetch https://clipy.online/video/abc123xyz.md — it's the transcript,
key-moment frames and click coordinates for a bug. Read it, then fix
the issue I point out in the recording.

If your Cursor Agent doesn't fetch it on its own, persist the convention once as a project rule (a file under .cursor/rules/) or in your repo's AGENTS.md: "Any clipy.online/video link is fetchable as .md for transcript, frames and click coordinates." After that, Cursor treats a pasted Clipy link like a readable source.

For repeat use, private recordings, library search, or authenticated inline frames, add the Clipy MCP server to Cursor. Cursor reads MCP servers from ~/.cursor/mcp.json (global — every project) or .cursor/mcp.json (project-scoped), per the Cursor MCP docs. The Model Context Protocol itself is an open standard; see the MCP specification.

Drop this into ~/.cursor/mcp.json:

{
  "mcpServers": {
    "clipy": {
      "command": "npx",
      "args": ["-y", "@clipy/mcp"],
      "env": { "CLIPY_API_KEY": "clipy_sk_live_xxx" }
    }
  }
}

Two gotchas that bite everyone:

  • Keep the -y. Without it, npx waits for an install confirmation that never comes in Cursor's non-interactive shell, and the server hangs on startup.
  • PATH. Cursor launched from the macOS GUI sometimes doesn't inherit your shell's PATH, so it can't find npx. Install Node via the official installer (system-wide PATH) or use the absolute path to npx in command.

Replace clipy_sk_live_xxx with your key from your Clipy account. Public recordings still work without a key; the key is what unlocks private recordings and search_recordings across your library. Once saved, Cursor exposes Clipy tools like get_transcript, get_summary, and search_recordings to the Agent — so "find the recording where I showed the checkout bug and read it" resolves without you pasting a URL at all.

End to end: bug → paste → fix → verify

Here's the whole loop with a real-shaped example.

1. Record the bug. Open the Clipy screen recorder (browser, Chrome extension, or Mac app), hit record, reproduce the bug, and narrate what's wrong while you do it: "watch — I click Save, the spinner runs, then the toast says success but the row never appears in the table." Stop. You get a share link in under two seconds.

2. Paste the link into Cursor. In Cursor's Agent, paste the link (Path A) or reference it through the MCP tool (Path B):

Read the Clipy recording at https://clipy.online/video/abc123xyz —
transcript, key moments and click coordinates. The Save flow reports
success but doesn't add the row. Find the bug, propose a fix, and
show me the diff before applying.

3. Cursor fetches the document and plans. It reads your narration, sees the key-moment frame at the moment you clicked Save (with the click coordinate landing on the Save button), and cross-references the transcript timing. It now knows the symptom precisely: optimistic success toast, no row insert. It grep-searches your repo for the Save handler.

4. Cursor writes the fix. It finds the handler firing the toast before the mutation resolves — or swallowing the insert error — and proposes the diff: await the mutation, only toast on a real 2xx, refetch the table. You review the diff in Cursor's normal flow.

5. Verify. Apply it, re-run the flow, and — the honest part — record a fresh Clipy clip of the working path if you want a paper trail on the ticket. The second recording's document becomes proof-of-fix that the next agent (or teammate) can read.

The point is that steps 3 and 4 used to require you to translate a video into prose by hand. Now the recording is the spec, and Cursor reads it.

Drag an MP4 into Cursor Paste a Clipy link
Does Cursor accept it? No native video input (July 2026) Yes — reads it as Markdown
What the model gets Nothing usable Transcript + summary + key-moment frames + click coordinates
Click precision — x/y coordinates + (Mac/extension) the AX element label you clicked
Setup — Zero for public links; one mcp.json block for private
Console/network logs No No — this is visual + spoken + click context, not a devtools trace
Cost — Free, no watermark, unlimited length

This is the same agent-readable pattern we cover in depth in what makes a screen recording agent-readable — the Cursor setup here is just one client for it. The Clipy MCP and skill work the same way in Claude Code, Codex, and any MCP- or skill-capable agent; see Clipy for agents for the full picture.

Frequently asked questions

Can Cursor watch a screen recording?

Not directly — Cursor has no native video input as of July 2026. But you can give Cursor the content of a screen recording by recording with Clipy and pasting the share link. Cursor fetches the recording as a Markdown document (transcript, key-moment frames, click coordinates) and reasons over that.

How do I paste a video into Cursor to fix a bug?

Record the bug with Clipy, copy the clipy.online/video/<id> link, and paste it into Cursor's Agent with a fix instruction. For public links no setup is needed — tell Cursor to fetch the .md version. For private recordings, add @clipy/mcp to ~/.cursor/mcp.json with your API key.

For a single public bug recording, the link alone is enough — the skill convention makes any Clipy link fetchable as Markdown with no install. Add the MCP server when you want private-recording access, library search, or authenticated inline frames inside Cursor.

Does the recording include console and network logs?

No. The Clipy document gives you the transcript, AI summary, key-moment frames, click coordinates, and (on Mac/extension recordings) the clicked element's Accessibility role and label. It does not capture browser console output or network request/response payloads — pair the recording with your server logs for silent backend errors.

Is Clipy free to use with Cursor?

Yes. Recording is free forever — unlimited length, up to 4K, no watermark, no credit card. Reading public recordings through the skill needs no API key. An API key (free to generate) unlocks private recordings and library search through the MCP server.