Screenshot Tool with Structured Export

You take the screenshot. You draw the box. You add the comment. You hit export.

And then the tool hands you a flat PNG with the annotations baked into the pixels. No metadata. No text. No timestamp. Just a picture of a picture, which you now have to describe again in the Linear issue you’re manually filing.

This is the gap most screenshot tools don’t talk about. Capture is solved. Export is not.

The capture-to-handoff gap

Every screenshot annotation tool does roughly the same thing in phase one: you grab the screen, draw shapes, add labels, maybe blur sensitive data. That part is fine. The problem starts when you try to use the output.

A PNG with red arrows baked in is not structured data. When a client opens it, they see the annotations. When a script processes it, it sees pixels. When you paste it into a Linear issue, you still have to type out what the arrows mean.

If you’re a freelancer delivering a client audit, you want a PDF with timestamped annotations and a summary you can send without reformatting anything. If you’re an engineer, you want JSON or Markdown so the feedback lands in your pipeline without manual copy-paste. If you’re a small team, you want the issue to appear in Linear or GitHub the moment you annotate it, with the screenshot attached and the annotation text as the issue body.

None of that is “export as PNG.”

What structured export actually means

Structured export means the annotation content survives the export as text, not just as pixels.

Concretely: when you annotate a screenshot with Loupe and export it, you get:

• PDF: the annotated screenshot, each annotation’s text, a timestamp per capture, and a sequential order you can share with a client or attach to a contract. No reformatting. You send the file.
• JSON: a machine-readable record of every annotation, including coordinates, content, and timestamp. Useful for developer pipelines, for building your own integrations, or for archiving feedback in a format a script can parse.
• Markdown: a structured writeup you can paste into a Linear issue description, a GitHub bug report, or a README. Each annotation becomes a bullet with its content and a reference to the screenshot.

The format you use depends on what you’re handing off to and who’s receiving it.

For freelancers: PDF reports that take 30 seconds

Most freelancers sending deliverables to clients are doing one of two things: emailing a screenshot-in-Slack that the client ignores, or spending 30 minutes in Notion building a feedback summary they should never have had to write manually.

The workflow with Loupe is different. You annotate the design or the staging build, you click export, and you pick PDF. What comes out is a document with:

• Each annotated screenshot in order
• The annotation text underneath each one
• A timestamp on every capture

You attach that to the invoice. The client can see exactly what you reviewed, what you flagged, and when. It doubles as an audit trail if there’s ever a dispute about what was in scope or what was flagged before launch.

If you’re doing a full UX or QA audit, the PDF means you stop writing reports and start annotating. The report writes itself.

For more on setting up a client feedback workflow from the start of a project, see how to annotate screenshots on Mac.

For developers: JSON and Markdown for your pipeline

If you’re wiring feedback into a CI process, a custom dashboard, or a QA automation layer, PNG files are useless. You need something a script can read.

Loupe’s JSON export gives you a structured record of every annotated screenshot session: coordinates of each annotation, the text content, the timestamp, and the URL of the page if you captured it via the web SDK. You can pipe that into whatever consumes structured data.

The Markdown export is the mid-point between “human-readable” and “paste-able.” Each annotation becomes a line item in a Markdown document that you can paste directly into a Linear issue description or a GitHub bug report comment, with the screenshot inline and the annotation notes as bullets.

For teams already deep in Linear, the fastest path is to skip the export step entirely and use the Loupe Linear integration. Annotate, push, done. The issue appears in your project with the screenshot attached and the annotation text as the body. No copy-paste, no reformatting.

The same applies for GitHub via Loupe GitHub bug reporting: annotate a bug, push it, and a GitHub issue appears with your screenshot and the annotation as the description.

How it compares to other tools

Tool	Capture	Annotation	PDF export	JSON/Markdown	Auto-push to Linear/GitHub
Loupe	Native overlay	Text + shapes + timestamps	Yes	Yes	Yes
CleanShot X	Excellent	Visual only	No	No	No
BugHerd	Widget-based	Text + pin	No	No	Limited
Skitch	Basic	Visual only	No	No	No
Manual screenshots	Basic	External editor	No	No	No

CleanShot X is the best capture tool for macOS. It is not a handoff tool. The comparison is not really apples-to-apples: CleanShot solves capture, Loupe solves the full capture-to-handoff loop. If you’re looking at CleanShot as a BugHerd alternative for structured feedback, that’s the wrong comparison axis.

The founder perspective on why this matters

I built the export layer before I built most of the UI features, which probably sounds backwards.

The reason is that I kept watching the same thing happen: a dev or a freelancer would find a great bug, annotate it beautifully, and then spend 10 minutes manually recreating it as a ticket. The annotation was already the ticket. The problem was that nothing could read it.

The export formats are not afterthoughts. They’re the point. Capture is commodity. Structure is the differentiator.

FAQ

Can I export annotated screenshots as a PDF?

Yes. Loupe generates a PDF that includes each annotated screenshot, the timestamp of the capture, and all annotation notes in order. You can share it with a client, attach it to a contract, or file it as an audit trail.

What structured export formats does Loupe support?

Three: PDF for client reports and audit trails, JSON for developer pipelines that need machine-readable feedback, and Markdown for README-style writeups or paste-into-Linear descriptions. Each format includes timestamps and annotation content.

Does Loupe push to Linear or GitHub automatically, or do I have to export manually?

Both. Loupe can auto-push each annotated capture directly to Linear as an issue or to GitHub as a bug report, with the screenshot attached and the annotation text as the issue body. You can also batch-export to PDF or Markdown for client handoff.

Is the export local or does it go through a cloud server?

Loupe processes exports locally. No screenshot or annotation data leaves your machine unless you explicitly push to Linear or GitHub. The PDF and JSON files are written to your local filesystem.

What’s the difference between Loupe’s export and just taking a screenshot in CleanShot X?

CleanShot X gives you a great capture. Loupe gives you a structured record. CleanShot annotates visually, but there is no export that carries the annotation content as structured text, no timestamp metadata per annotation, and no direct push to your project management tool. Loupe is built for the handoff, not just the capture.