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, tested live 2026-09-17 (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 Receipt {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 — 100+ 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.

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?