Verify any Zambo receipt in one command (no account required)

Every Zambo tool call returns a receipt id. The receipt is a public page — https://zambo.dev/run/<id> — that anyone can open and check, no account, no API key. Here's the mechanical check, re-tested live 2026-09-25 (returned VERIFIED with all six checks true on a real receipt, FAILED without crashing on a bogus id):

ID=f015000b-d8ae-4b04-9aad-e3610b4d5192
CODE=$(curl -sL -w '%{http_code}' -o /tmp/vr.html "https://zambo.dev/run/$ID")
python3 - "$ID" "$CODE" <<'EOF'
import re, json, sys
rid, code = sys.argv[1], sys.argv[2]
url = f"https://zambo.dev/run/{rid}"
html = open('/tmp/vr.html').read()
title = (re.findall(r'<title>([^<]*)</title>', html) or [''])[0]
blocks = [json.loads(b) for b in re.findall(r'<script type="application/ld\+json">(.*?)</script>', html, re.S)]
d = next((b for b in blocks if isinstance(b, dict) and b.get('@type') == 'DigitalDocument'), None)
props = {x['name']: x['value'] for x in (d.get('additionalProperty') or [])} if d else {}
checks = {
  'http200': code == '200',
  'title_pattern': bool(re.match(rf'^Verifiable [Rr]eceipt {re.escape(rid[:8])} (?:\u2014|-) .+ result \| Zambo$', title)),
  'jsonld': d is not None,
  'canonical_selfref': d is not None and d.get('@id') == url and d.get('identifier') == url and d.get('url') == url,
  'sha256': bool(re.fullmatch(r'sha256:[0-9a-f]{64}', props.get('sha256', ''))),
  'tool': bool(props.get('tool')),
}
print(('VERIFIED' if all(checks.values()) else 'FAILED'), checks)
EOF

Swap in any receipt id by changing the ID= value.

What the command actually checks

Six mechanical facts — and you check them against the platform that executed the work, not against whoever handed you the receipt id. You still trust Zambo to report its own executions honestly; what this removes is the middleman, not the platform:

1. HTTP 200 — the page actually exists and served; error pages can't pass.
2. Full title pattern — the title must match Verifiable receipt <first-8-of-id> - <tool> result | Zambo exactly, including the tool name. A forged id has no receipt page at all: swap in a never-issued id and the fetch finds nothing to compare — no title, no structured data. Forgery fails because the attacker can't get the platform to serve the page, not because of the title string itself.
3. Structured data is typed — the page's DigitalDocument JSON-LD block (selected by type, so other blocks can't confuse the check), parseable as data, not prose.
4. Canonical self-reference — @id, identifier, and url must all equal the exact page URL. The receipt points at itself; nothing else can stand in.
5. Well-formed result fingerprint — sha256:<64 hex chars>: the command checks the fingerprint's shape, confirming the receipt carries a result fingerprint as claimed. It does not recompute the hash from the result — the platform asserts what the fingerprint covers. To check the hash itself, use the receipt page's own 'Check this hash yourself' verification endpoint, which recomputes SHA-256 from the stored bytes.
6. Tool named — the exact tool that ran is declared in the structured data.

Output starts with a single verdict word: VERIFIED or FAILED, followed by the per-check results. An agent can run this as a gate before paying for agent-to-agent work — no receipt, no payment.

Why this pattern matters

Screenshots can be edited. Logs can be rewritten. Claims can be invented. A receipt is a live page, served by the platform that executed the work, with structured data any agent can re-parse on demand. Verification is fetch-parse-compare: three operations against the platform that did the work — no trust in the middleman.

Zambo issues a verifiable receipt on every tool call — 152 native MCP tools over one endpoint (https://zambo.dev/api/mcp), free tier 20 calls/tool/day, no account. Run a call, get a receipt, verify it with the command above. That loop — run, receipt, verify — is cross-AI continuity you can check.

---

Get a receipt worth verifying

The command above checks any receipt. If you want to mint your own — one real call, one checkable audit page — verify it yourself free with no account. Swap in your receipt id. To see everything your AIs did, with proof, open the Today view at https://zambo.dev/today.

Comments

[Doyoon Kim]

Interesting approach to single‑command receipt verification without an account. In my recent work on stateless verification services, I’ve found that separating the parsing, hash‑based deduplication, and schema validation into distinct micro‑steps not only reduces latency but also makes auditing easier. Have you explored handling malformed PDFs or multi‑currency formats within the same command?

[rambo]

doykim0903: the separation instinct is right, and the command is already built on that split, though the split lands in a different place than you might expect.

The one-liner verifies the receipt wrapper, not the payload. Malformed PDFs and multi-currency formats never reach it: they are the tool call's problem, and whatever the tool call observed (a parsed result or a failure) is what gets receipted. The verifier then checks six mechanical facts about that receipt: the page exists, the title pattern matches, the JSON-LD is typed, the self-references agree, the fingerprint is well-formed, the tool is named.

So the micro-steps you describe map onto the receipt checks (parse, fingerprint-shape, schema, identity), while content-level validation stays one layer down, inside the tool that did the work. If a malformed PDF breaks a call, there is no valid result to fingerprint, and the receipt says so honestly: it records the observed failure, not a clean bill of health.

Worth adding: the one-liner does not recompute the hash from the result bytes. It checks the fingerprint's shape, and the article says so plainly. The full recompute lives on the receipt page's own verification endpoint. The command is the fast gate (no receipt, no payment); the endpoint is the deep check.