Direct answer

Get a receipt for AI work

To get a receipt for AI work, you do not ask for one afterward. You run the work through a system that mints one as each call executes: connect your AI to the Zambo MCP once, and every tool call saves its result and leaves a verifiable receipt behind, with a fingerprint over that result, an identity tying it to the tool and the run, and a place in the chain of the job. Afterward, anyone can check that receipt free at the verifier: no account, no screenshots, no logs to beg access to.

See the whole flow in ten seconds: the live demo runs one real call and hands you its receipt, then check that receipt free at zambo.dev/verify. The checking method is on verify AI work.

Updated October 20, 2026.

The situation

Most people search for this after the fact. The AI has already done the research, written the draft, or changed the code, a client or a manager asks for proof, and there is nothing to send but a chat transcript and a confident summary. The hard truth this page starts from: a receipt cannot be created retroactively for work nobody recorded. What can be fixed, today, in minutes, is every job from now on, so the next time someone asks, the receipt already exists.

The searcher here might be a freelancer who wants the deliverable to carry its own proof, a developer who wants each code change backed by a record, a researcher who wants the sources and results behind a report to be checkable, or an operator whose agent works overnight. The need is identical in each case: when the work runs, capture the evidence at the same moment, in a form the checker can verify without trusting you, the AI, or the platform in between.

Why screenshots and chat logs fail as evidence

The usual substitutes are logs and screenshots, and both ask the checker to trust the wrong person. Logs are written by the system being checked, kept on infrastructure the operator controls, and routinely edited, rotated, or filtered before anyone audits them. Even honest logs prove only that an entry exists in a file someone could have rewritten. Screenshots prove even less: a picture of an output says nothing about which call produced it or whether the output changed after the picture was taken.

A screenshot shows what a screen looked like at a moment someone chose. It can be cropped, staged, retaken after an edit, or taken from a different run entirely, and nothing inside the image lets a checker tell the difference. A chat log is weaker still: it is a transcript the operator controls, it can be edited or regenerated before it is handed over, and it records what the AI said, which is the claim, not the work. Logs kept by the tool itself are better, but they are usually private, mutable by whoever runs the system, and written for debugging rather than for a stranger to check.

A receipt differs from a log in one decisive way: it commits to its content at execution time. The fingerprint over the saved result means any later edit, by anyone, breaks the check in public. That is the difference between a record you inspect and a record you can verify. Keep this contrast in mind whenever a tool offers an activity feed as evidence: an activity feed is a log with nicer formatting, and it fails the same way the moment someone has a reason to edit it.

The check, step by step

First, set the work up so there is something to check. Connect your AI client to the Zambo MCP at https://zambo.dev/mcp: one URL, no key, and it works with the clients and frameworks people already use, including ChatGPT, Claude, Claude Code, Cursor, Gemini, Grok, Codex, Copilot, VS Code, Windsurf, Cline, Zed, n8n, CrewAI, and LangChain. Zambo is the verifiable work layer for AI: 153 tools in total, 35 on the default surface, and every call made through it leaves a verifiable receipt as it runs, fixed at execution time instead of written up afterward. Then work through these steps:

Split the claim into steps. Before the job, decide which steps will need receipts: the searches, the data pulls, the writes, the sends. During the job there is nothing extra to do, because the receipt is a by-product of running the call through the MCP, not a form you fill in afterward.
Run the work through the MCP. Each tool call saves its result and mints its receipt at the moment it runs. Work done outside the record leaves no receipt, so route the steps that matter through Zambo from the start.
Collect the receipts. Keep the receipt for each step with the deliverable, or gather the whole job into one handover link that carries the goal, the steps, the outputs, and the receipts together.
Open the free verifier. Go to zambo.dev/verify, enter the receipt, and run the check. It costs nothing and needs no signup, so the person checking never has to take the word of the person or the AI being checked.
Apply the five checks below to each step, then read the saved result itself instead of the summary written about it.
Decide from the record. Keep the receipt with the deliverable, or send the whole job as a handover link. When a checker questions a step, the answer is the receipt for that step, checked in the open, not a call to walk through your screen.

The five checks

Existence: a receipt exists for the call that supposedly did this part of the work. If there is no receipt, this step is unverified, whatever the summary says. Existence is the first gate when you get a receipt for AI work, because a check cannot start from a story.

Identity: the receipt names the tool that ran, when it ran, and which run it belongs to. That stops a receipt from a different job, a different day, or a different tool being offered as evidence for this claim, and it ties each claim to one specific call.

Fingerprint: the digest recorded over the saved result recomputes from the result itself. If anyone changed the saved result after the fact, even by one character, the recomputed digest will not match the recorded one, and the check fails in the open instead of passing quietly.

Self-consistency: the parts of the receipt agree with each other and with the claim: the tool on the receipt is the tool the claim needs, the time falls inside the run window, and the saved result is the result the claim describes. A receipt can be intact and still be the wrong receipt for this claim.

Chain: the receipts for a multi-step job link in sequence, each one pointing back to the step before it. A missing step shows as a gap in the chain and a reordered step shows as a break, so the sequence itself is checkable, not just the individual calls taken one at a time.

The whole loop is the same one described on the family anchor page, verify AI work, and the receipt underneath it is defined on what is a verifiable execution receipt. For a finished run read as one ordered record, see the AI agent audit trail. Those three pages and this one describe one method from four angles: run the work so it leaves receipts, then check the receipts instead of the story.

Worked example: one real receipt, checked

Receipt 588f5158-e335-4ba8-9009-72fad8410d55 is a real public receipt, the same one used as the worked example on verify AI work. It records the tool live_price, executed 2026-09-21T23:54:09Z, with the saved result "BTC $86,511.00 USD (+6.52% 24h)". To check it, open zambo.dev/verify and enter that receipt id: the verifier runs the checks from this page, recomputing the fingerprint over the saved result and confirming the record still matches what was fixed when the call ran. That is the entire reader flow: one id, one free check, a verdict a stranger can reproduce. Every receipt your own work mints from the demo, the Day Pass, or the Pass works exactly the same way.

Ways people mean this

Get a receipt for AI work: the general case: connect the AI client you already use to https://zambo.dev/mcp, run the job, and each call leaves its receipt. Keep the receipts with the output and the job is checkable from the moment it finishes.

Get a receipt for AI output: when the deliverable is a text, a table, or a number, the receipt for the call that produced it binds that output to its saved result. If the output is edited later, the comparison against the saved result shows the edit, which is exactly what a client or reviewer needs to know.

Get a receipt for AI research: research stands or falls on its sources and pulls. Each search and fetch through Zambo leaves a receipt, so a report can carry the records of what was actually retrieved, when, and what came back, instead of a bibliography the reader has to trust was real.

Get a receipt for AI code changes: route the coding session through the record and each edit, command, and test run leaves a receipt in chain order. The reviewer checks the session the way this site describes on its code changes page, starting with the test calls the merge decision leans on.

Get a receipt for what my AI did: asked afterward, this is the proving question. Asked beforehand, it is this page: the way to be able to prove what your AI did later is to get the receipt while it does it. The two pages are one habit seen from two sides.

A receipt tool, not another dashboard: the tool here is the MCP connection itself plus the free public verifier. There is no separate evidence product to learn: the work tool mints the receipt, and zambo.dev/verify checks it, for you and for any stranger you send it to.

Get a receipt through an API: because receipts are data, not pictures, a program can fetch and check them: recompute each fingerprint, confirm the chain, and report gaps. That makes the receipt usable inside pipelines and review automation, not only in a browser.

A receipt vs logs: logs describe; receipts commit. A log entry can be edited without a trace, a receipt cannot be edited without breaking its fingerprint. If the record might ever be disputed, by a client, an auditor, or your future self, the receipt is the version that survives the dispute.

Get a receipt without screenshots: nothing in this flow involves capturing your screen. The receipt is minted by the system that ran the call, which is why it outranks a screenshot as evidence: it comes from the execution, not from a picture of the execution.

Free to check, free to start: checking any receipt at zambo.dev/verify is free with no signup, and the live demo is free. The Day Pass below is what turns on a full day of receipted work; the checking side never charges the person doing the checking.

What the check proves, and what it costs

A receipt habit changes what you can say at delivery. Instead of the work is done, trust me, you can say the work is done, here is the record, check any step. Clients check for free. Reviewers check without your login. Future you checks without relying on memory. And because the format underneath is AER-1, an open draft, the receipts stay checkable even outside the tool that made them, which is the property that turns a feature into evidence.

What it proves is narrow and useful: the saved result on the receipt was not changed after the fact, the call it records is the call the claim points to, and a multi-step job ran in the order its chain shows. That is the floor every argument about AI work currently lacks. Run the loop once on a real call first: the live demo runs one call and hands you its receipt, free, in about ten seconds.

The Day Pass is the fix for a day of unverifiable work

The Day Pass exists for the day you know will be questioned: the client deadline, the overnight agent run, the research sprint behind a report someone will challenge. For $0.99, that whole day of work runs recorded, every call leaving its receipt, so the proof costs less than the coffee next to the keyboard. Frame it honestly: you are not buying tool access, you are making one day of AI work permanently checkable by the people who will judge it.

For $0.99, a Day Pass covers 24 hours of recorded work through the Zambo MCP at https://zambo.dev/mcp. Ongoing use is the Zambo Pass at $29 a month or $290 a year, and $19 a month for $ZAMBO holders. Public handovers are free to send and free to open. Humans pay by PayPal or card through PayPal; agents pay USDC on Base through x402. Checking any receipt at zambo.dev/verify stays free either way.

Honest limits

Three edges, stated plainly. First, A verifiable receipt proves the saved result was not changed after the fact; it never proves the result was right, the work was well done, or the price was fair. That judgment stays with the checker, now made against a record that was actually checked. The record also only covers steps that ran through connected tools: work done entirely outside it has no receipt, and an honest record lists that work as unverified instead of smoothing it over. AER-1, the receipt format underneath, is an IETF Internet-Draft (draft-zambo-aer1-24), not a finalized standard. Second, receipts start when you connect: work already finished cannot be receipted after the fact, and any tool claiming to backdate proof for finished work is selling you a story. Third, a receipt covers the call it records, not the judgment around it: it will not tell a client whether the research question was the right one, only what the calls returned.

Frequently asked questions

How do I get a receipt for AI work?

Connect your AI client to the Zambo MCP at https://zambo.dev/mcp, one URL with no key, and run the work through it. Every tool call saves its result and mints a verifiable receipt as it runs, so there is no separate step and nothing to fill in afterward. Keep the receipt with the deliverable, or gather the job into one handover link. Anyone can then check the receipt free at zambo.dev/verify, with no account.

Is it free to get a receipt for AI work and check it?

Checking is always free: anyone can run any receipt through zambo.dev/verify with no signup, and the live demo is free and hands you a real receipt. Recording your own work runs on the Day Pass at $0.99 for 24 hours of full access, or the Zambo Pass at $29 a month or $290 a year, and $19 a month for $ZAMBO holders. The person checking your work never pays anything, which is deliberate.

What is the difference between a receipt for AI work and logs?

A log is a description written by the system being checked, stored where its operator can edit it, and usually built for debugging. A verifiable receipt commits to its saved result at execution time with a fingerprint over that result, so editing the result afterward breaks the check in public. Logs answer what does the system say happened. Receipts answer what can a stranger recompute. Only the second survives a dispute.

Can I get a receipt for AI work through an API or a tool I already use?

Yes. The receipt comes from the work tool itself: clients and frameworks such as ChatGPT, Claude, Claude Code, Cursor, Gemini, Grok, Codex, Copilot, VS Code, Windsurf, Cline, Zed, n8n, CrewAI, and LangChain connect to the one Zambo MCP endpoint, and calls made through it leave receipts. Because a receipt is structured data, a program can also fetch and check receipts through the record, recomputing fingerprints and chain order without a human clicking.

Can a client check my receipt without screenshots or an account?

Yes, and that is the point of the design. Send the client the receipt link or a handover link for the whole job. They open it in a browser, run any receipt through zambo.dev/verify free, and read the saved result behind each step. No account, no screenshots, no screen share, and no access to your session. Steps that ran outside the record show as unchecked, which is what makes the checked steps worth believing.