TL;DR — QUICK ANSWER

Use Clipy by choosing the Mac app, Chrome extension, or web recorder, capturing one clear task, and sharing the normal watch link. The same link gives people a playable video and, with the Clipy skill, gives agents an AREC document with requests, key moments, evidence, capture gaps, and transcript.

This article was fully reviewed and updated in August 2026. Clipy is no longer only a small Chrome recorder. The current product includes a native Mac recorder, agent-readable recording documents, optional redacted browser diagnostics, agent proof recordings, screenshot annotation, YouTube and local-video context import, viewer Q&A, transcripts, summaries, and key moments. The permanent, product-maintained version of the workflow is the complete Clipy field guide. Use that page when you want the latest visual walkthroughs; use this article when you want the reasoning and practical habits behind them.

What is Clipy now?

Clipy is a screen recorder and context handoff system. The human side is familiar: record your screen, stop, and paste a share link. The viewer opens a normal web page, watches without creating an account, and can use the transcript, summary, key moments, and Q&A when those artifacts are ready.

The agent side is the important difference. A conventional video link asks a coding agent or assistant to deal with a media file it may not be able to watch accurately. Clipy precomputes a structured companion document called AREC. It can contain the recording’s intent, extracted requests, a draft plan, timestamped key moments, selected frames, pointer evidence, optional browser diagnostics, explicit capture gaps, and the transcript. With the Clipy skill installed, you paste the normal watch link and the agent fetches that context automatically.

This does not make the recording an authority that overrides your instructions or the repository. It makes the recording usable evidence. A bug report can carry the route, spoken expected behavior, failed request shape, click location, and frame from the failure. A design review can carry the element you pointed at and the measured change you requested. A verification run can carry evidence marks showing the state the agent exercised.

Which Clipy recorder should I use?

Every recorder ends at the same kind of Clipy share link. Choose based on the surface you need to capture.

Use the Mac app for native workflows

The Clipy Mac app is the best choice when the work crosses browser tabs and native apps, needs system audio, or benefits from exact window capture. It runs as a focused macOS recorder: choose a source, count down, record, stop, upload, and copy the link. Use it for Figma reviews, desktop-app bugs, terminal and editor walkthroughs, or any flow where the browser alone is not the full story.

The Mac app also owns Flare, Clipy’s temporary pointer spotlight. Hold Control while recording and move the pointer around the element you mean. The warm trail fades instead of permanently drawing over the interface. Flare is especially useful when “this button,” “this spacing,” or “this state” would otherwise make the recipient guess.

Use the Chrome extension for tabs and bug evidence

The Chrome extension is the fastest path for a browser tab, window, display, or camera recording. It is the best choice for web-app demos and reproductions because the capture starts near the page you are already using.

For a bug report, you can optionally enable “Also capture my bug flow.” This attaches bounded, redacted diagnostics such as warnings, errors, failed fetch or XHR status, request method, duration, and sanitized URL shape. It does not capture request or response bodies, headers, cookies, authentication tokens, raw query values, or typed form values. Console messages are still page-authored text and redaction is best effort, so use safe test data and review sensitive recordings before sharing.

Use the web recorder when you want no install

Open the Clipy web recorder when you want to record immediately without installing the extension or Mac app. It is a good default for a short browser walkthrough, support reply, async update, or product explanation. The recording upload streams toward the server while you work, then the processed MP4 becomes the durable playback file.

How do I make my first Clipy recording?

  1. Sign in and choose one safe surface. Clipy recording is authenticated. Select the exact tab, window, area, or display needed for the task. Avoid a full display when notifications, private tabs, email, or customer information could appear.
  2. Check the microphone and camera before starting. Use the mic meter or the mic and webcam test. If another app owns the camera or the browser has blocked microphone permission, fix that before the real take.
  3. State the task in the first sentence. “I am reproducing the checkout failure as an organization admin on Safari” is more useful than “here is the issue.” Name the route, role, test data, and expected result when they matter.
  4. Perform one clean pass. Narrate each action once. Pause at the important state. For a bug, say actual versus expected. For design feedback, say current value versus target value. For a walkthrough, state the decision and why it matters.
  5. Stop and wait for the share link. Clipy processes the recording for broad MP4 playback and generates transcript, summary, key moments, and other context in the background. Processing failures are surfaced instead of pretending the recording is ready.
  6. Rename the recording before broad sharing. A useful title says what the recipient will learn or decide: “Safari checkout button ignores first click,” not “Recording 12.”

After the first successful recording, Clipy may show a one-time next-step recipe based on the recording kind, onboarding intent, and capture source. Treat it as a shortcut into the relevant part of the field guide, not a required wizard.

How do I record a bug an agent can fix?

A useful bug recording begins from a known state and ends with one visible mismatch. State the browser or app version, account role, route, and test record. Perform the minimum reproduction steps. When the failure appears, stop moving the pointer and say: “Actual: the Save button stays disabled. Expected: it enables after the required title is entered.”

Then paste the Clipy link into the coding agent with a bounded request:

“Reproduce the behavior in this Clipy recording, find and fix the root cause, run the focused checks, and send Clipy proof of the corrected user-visible flow.”

With the skill installed, the agent can read the AREC context behind the normal link. If diagnostics were captured, it can use the sanitized error and network evidence. If diagnostics were not captured, AREC should describe that as a capture gap; absence of a sidecar is not evidence that no error or click occurred.

The agent should still reproduce the problem and inspect the real code. A transcript can be mistaken, a page can emit misleading console text, and a single recorded path cannot prove every role or branch. Clipy shortens the path to the relevant evidence; it does not remove engineering judgment.

How do I use Clipy for design feedback?

Open the real build, not only the design file. Use Flare on Mac to point at one element and state a measurable delta. A strong note sounds like this:

“This CTA has 20 pixels of horizontal padding. The mock uses 32 pixels, our space-8 token. Keep its height and radius unchanged.”

A weak note sounds like “the button feels cramped.” The weak note may be a valid reaction, but it asks the developer or agent to make the design decision. The strong note identifies the element, current state, target state, and scope boundary.

Move through structure before polish: layout, spacing, typography, color, radius, interaction states, responsive behavior, and motion. Pause after every note. Then ask the developer’s agent to map each measured delta to the owning component and existing design token, make the smallest change, and return a proof recording of the corrected state.

For the detailed workflow, read how designers use Clipy Flare for design iteration.

How can an agent prove its work with Clipy?

“Tests pass” is useful evidence for code behavior, but it is not proof that the user-visible path works. Clipy lets an agent record the verification surface and return a normal watch URL plus the agent-readable AREC URL.

For a headless web run, Clipy can launch a recording session around the verification command. For an existing browser, Mac app, simulator, or native window, the agent can select the exact capture source and add timestamped evidence marks. If another tool already produced screenshots or a WebM or MP4, the clipy proof command can turn those artifacts into a short verification recording without forcing a second browser-control dependency.

The right proof records the smallest narrative that distinguishes success from failure: open the target, perform the action, show the expected result, and mark that moment. A failed wrapped command should not upload a celebratory proof. A successful proof should describe what was exercised and what the visible evidence showed.

How do I give YouTube or local-video context to an agent?

Clipy’s context import is for videos you did not record as a hosted Clipy share. Run clipy context import "https://youtu.be/..." --sync --json for a YouTube URL, or pass a supported local video file. Clipy creates a private local AREC bundle with metadata and a timestamped transcript. When sync is requested, the server classifies the material and asks the local process for frames around the moments where visual evidence matters.

The source media does not need to become a public Clipy recording. Derived text and selected frames can sync while the full source stays local. This is useful for a long product demo, conference talk, customer walkthrough, or tutorial you want an agent to search and act on without watching from the first second.

Use the YouTube-to-agent-context guide for the complete import flow.

What can I do with screenshots in Clipy?

Clipy can also capture and share screenshots. Upload or paste a PNG, JPEG, WebP, or GIF, then annotate it with arrows, shapes, text, blur, crop, or other editor tools. The public share page lives at a short /s/... link, while the library and editing routes stay owner-only.

Editing is non-destructive: the pristine source is preserved and annotations are replayed over it, so reopening the editor can move an arrow instead of drawing over baked pixels. Use a screenshot when one state explains the issue. Use a recording when sequence, interaction, speech, or timing carries the meaning.

What does free include, and when should I upgrade?

For accounts created on or after 7 August 2026, free includes a one-time allowance of 15 recordings or 120 recorded minutes, whichever is reached first. It is not a monthly quota and it has no expiry date. Deleting recordings does not restore the allowance. Everything already recorded stays playable, shareable, and downloadable. Accounts created before the cutover are grandfathered and remain uncapped.

Every free recording can still use the core context features: no watermark, no viewer signup wall, AI titles, summaries, transcripts, key moments, AREC, agent skill and MCP access, Q&A, search, viewer analytics, embeds, and MP4 download. There is no per-recording duration cap.

Clipy Pro is $9 monthly or $72 annually, which is a $6 monthly equivalent and 33% less than paying monthly. Pro removes the recording allowance and adds 4K capture, whole-library Loom migration, end-of-video calls to action, new features first, and priority support. Eligible countries see lower annual regional pricing automatically. There is no trial countdown; upgrade when Clipy has earned a permanent place in your workflow.

What are the best habits for a useful recording?

  • One recording, one coherent outcome. Split unrelated bugs, design reviews, or decisions.
  • Start from a known state. Name role, route, device, and test data when they affect the result.
  • Point, pause, and finish the sentence. Fast pointer movement creates ambiguous evidence.
  • Say actual versus expected. Do not make the recipient infer the desired result.
  • Use safe data. Isolate the window and close notifications.
  • Ask for an evidence-backed return. A fix should come back with focused checks and a visible proof path.
  • Keep durable decisions in their real system. Clipy carries context; the repository, design system, issue tracker, and operating docs remain sources of truth.

Frequently asked questions

Do viewers need a Clipy account?

No. Public-by-link recordings play without a Clipy account. Owners must sign in to record, edit, manage access, or delete. Restricted recordings still enforce their configured access rules.

Yes. Install the Clipy skill once, then paste the normal watch URL. The skill resolves the AREC document automatically. The public .arec, .md, JSON, and transcript routes are implementation surfaces, not something every teammate needs to memorize.

Does Clipy record console logs by default?

No. Browser diagnostics are optional and off by default. The user must enable the bug-flow capture for that recording. Even then, the capture is bounded and excludes bodies, headers, cookies, tokens, raw query values, and typed form values.

Can Clipy fetch any frame at any timestamp?

No. Clipy serves already-generated key-moment frames and crops. Arbitrary on-demand frame extraction would force expensive video download and decoding on the server. Agents should use the selected evidence and report when a needed visual is absent.

Does the free allowance reset each month?

No. New free accounts receive a one-time allowance of 15 recordings or 120 minutes, whichever comes first. It does not expire, but it does not reset. Deleting recordings does not restore it. Older accounts created before 7 August 2026 are grandfathered and uncapped.

What happens to old recordings if I hit the limit?

They stay playable, shareable, and downloadable. The quota prevents starting new recordings; it does not erase or shorten work already created.

What is the complete Clipy loop?

Record the real surface. Point at what matters. State the intent or expected result. Share one normal link. Let the recipient or agent act from the evidence. Then require a proof recording of the working result.

That loop is the durable way to use Clipy in 2026: not just as a faster way to make a video, but as a way to keep the context attached from explanation through implementation and verification.

Open the complete Clipy field guide →

Paste the normal watch URL into the system where the work already lives: Slack, email, a GitHub issue, a project task, a support conversation, or a design review. Do not make the recipient hunt through a separate library first. Give the link a one-sentence frame such as “the failure appears after the second Save click at 0:42” or “the four measured design changes begin at 1:10.”

Public-by-link does not mean searchable or advertised, but anyone who receives the URL can forward it. Use restricted access when the recording should only open for selected people. Delete a recording from the owner library when the link should stop resolving. The viewer never needs an account for an ordinary public share, and already-created recordings stay playable even when the owner later reaches the free recording allowance.

For an agent handoff, paste the same URL and state the outcome you want. Do not paste a transcript into the prompt unless the agent lacks the Clipy skill. The skill reads the structured recording context and can search only the relevant moments instead of forcing the agent to treat thousands of transcript words as equally important.

How do I troubleshoot a Clipy recording?

Why is my microphone silent?

Check the microphone meter before recording. In Chrome, open the site permission control in the address bar and allow the intended input device. On Mac, confirm the app has microphone permission in System Settings and that another application has not taken exclusive control of the device. If AirPods or a USB microphone appear, select the exact input instead of assuming the system default followed your last change.

Why is system audio missing?

Browser capture rules depend on the chosen source and operating system. A Chrome tab can expose its own audio when “Share tab audio” is selected. Capturing arbitrary system audio from a browser is more limited on macOS. Use the native Mac recorder when the workflow depends on desktop or application audio outside one browser tab.

Why is the camera preview black?

Quit or pause applications such as Zoom, Meet, or FaceTime that may own the camera. Reopen the Clipy source picker and select the intended device. A preview problem should not be solved by repeatedly starting real recordings; use the mic and webcam test until the correct device produces a stable image.

Why is processing taking time?

The recorder uploads capture bytes, then the server validates and converts the result into a cross-device MP4. Transcript, summary, and key moments are separate enrichments and may finish after playback becomes available. A processing page should show whether the recording is queued, processing, ready, or failed. If it fails, retrying the same broken browser state is less useful than sharing the recording identifier and visible error with support.

Why does the agent say it cannot read the video?

Install or update the Clipy skill for that agent, then give it the normal link again. A public recording’s AREC document needs no API key. Private recordings and library search require authenticated Clipy access. If a particular frame or diagnostic is missing, that may be a real capture gap; the agent should report it rather than pretending the absent evidence says nothing happened.

How do I decide between video, screenshot, and written text?

Use written text for a durable fact that needs no demonstration: an acceptance criterion, a date, a policy, or a short decision. Use a screenshot for one visual state: an alignment issue, error dialog, dashboard result, or annotated mock. Use a recording when the order of actions, timing, movement, narration, or transition between states carries the meaning.

The strongest handoffs often combine them. The task holds the durable acceptance criteria. The Clipy recording shows the actual behavior. Key-moment frames make important states skimmable. The proof recording shows the result after implementation. Each artifact has one job, and none is asked to replace the system that should own the information permanently.

Next step: open the visual field guide, choose one workflow you have not used, and make the next recording carry enough evidence that the recipient can act without scheduling a clarification call.