Cryptographic proof of what your AI agent decided and why, before it acts.

ProofRelay seals an agent's inputs, policy, and reasoning before it acts. Provably untampered, not just logged. Verify a real receipt right now:

Verify A Live Receipt →
Opens the raw API response · no account, no API key
Where ProofRelay Sits
Between the decision and the action
AI agents propose decisions, ProofRelay seals each decision into a cryptographic receipt before execution, and only then does the action run: payments, trades, claims, approvals, API calls, data updates, and notifications
Protocol Overview
How the seal
works
01 // EXECUTE

Submit Your Action

POST your agent's decision (inputs snapshot, ruleset, and reasoning trace) to /api/execute/decision. Attach your API key. ProofRelay seals it before anything executes.

02 // SEAL

Receipt Generated

ProofRelay hashes your payload with a server-side secret, timestamps it, and stores the receipt. Alter any stored field and the recomputed seal no longer matches. Your response includes a receipt ID and the seal value.

03 // VERIFY

Recomputation-Based Check

At any point, seconds or years later, call /api/verify/decision?id= with the receipt ID. ProofRelay recomputes the seal from stored fields rather than returning a stored flag. Any field alteration produces a mismatch. No API key required. Any counterparty can verify independently.

04 // TRUST

Provably Untampered

Your auditors, regulators, or counterparties now have cryptographic proof of why the decision was made. Not reconstructed from logs. Sealed before execution.

The Evidence
Anatomy of a receipt
GET /api/verify/decision?id=b5a3f9fb-ca19-4dce-ace2-f01183c09ad9 { "seal_ok": true, "receipt_id": "b5a3f9fb-ca19-4dce...", "agent_id": "treasury-agent-v2", "decision_result": "EXECUTE", "conditions_evaluated": [ 4 PASS ], "inputs_captured_at": "2026-07-03T17:56:23Z", "decision_made_at": "2026-07-03T17:56:25Z", "receipt_sealed_at": "2026-07-03T21:19:01.247Z", "snapshot_hash": "f54cb43bcaaec6a7...", "trace_hash": "5abb10344155d13d...", "seal": "hmac-sha256:-c9fHsQRx5T5Rkez...", "anchoring": { "status": "pending" } } RECOMPUTED AT REQUEST TIME seal_ok is never a stored flag. Any stored field altered, this returns false. THREE-TIMESTAMP LIFECYCLE Inputs captured, decision made, receipt sealed. The sealing moment is server-generated. REASONING ATTESTED, NEVER STORED Only the hash of the reasoning trace is kept. The raw trace stays with the operator. ONE SEAL BINDS EVERY FIELD HMAC-SHA-256 over the full decision context. Change anything and the seal breaks.
This is the live healthcare treasury receipt from the case studies below. Verify it yourself →
Real-World Applications
Case studies

Still figuring out where ProofRelay fits? These scenarios show exactly what gets sealed, who verifies it, and what it proves across four industries where AI agents are already making consequential decisions.

All scenarios are fictitious examples for illustration purposes.
01 // HEALTHCARE
Treasury Wire Authorization
$2.4M wire · SOX compliance · AI treasury agent
Riverside Health System's AI treasury agent evaluates a $2,412,500 wire transfer against four board-approved controls: vendor approval, OFAC screening, daily limits, authorization thresholds. The receipt is sealed before the wire instruction reaches the bank. Six months later, a SOX auditor verifies every condition independently with just a receipt ID.
Verifier: SOX auditor · internal audit team · reinsurer
Read the case study →
SAMPLE RECEIPT: HEALTHCARE TREASURY Verify live receipt →
seal_oktrue
agent_idtreasury-agent-v2
operator_idriverside-health-system
action_typewire_authorization
ruleset_idtreasury-wire-policy-v7
conditions_evaluated
amount_below_single_auth_limitPASS
daily_cumulative_within_limitPASS
approved_vendor_active_contractPASS
ofac_screening_clear_within_24hPASS
timestamps
decision_resultEXECUTE
rationaleWire of $2,412,500 to MedEquip Partners LLC. All four conditions passed. Authorizing wire for bank submission.
inputs_captured_at2026-07-03T17:56:23Z
decision_made_at2026-07-03T17:56:25Z
receipt_sealed_at2026-07-03T21:19:01.247Z
snapshot_hashf54cb43bcaaec6a7a230ae3df85ae5d2aa5a2d51fdb934b36b76ebffb2fe021c
sealhmac-sha256:-c9fHsQRx5T5RkezlcxT_2xGcaPfycoxnqr7HO0Ilvc
02 // INSURANCE
AI Claims Approval
$1.8M claim · bad faith litigation · pre-decision sealing
Meridian Commercial Insurance's claims agent approves a business interruption claim, evaluating policy form version, fraud screening score, and Ohio's prompt payment deadline. The receipt is sealed before the approval notice is sent. Eight months later, plaintiff's counsel in a bad faith lawsuit verifies the decision record directly. No insurer involvement required.
Verifier: plaintiff's counsel · state insurance regulator · special master
Read the case study →
SAMPLE RECEIPT: INSURANCE CLAIMS Verify live receipt →
seal_oktrue
agent_idclaims-adjudicator-v5
operator_idmeridian-commercial-insurance
action_typeclaim_approval
ruleset_idclaims-handling-policy-v9
conditions_evaluated
coverage_trigger_confirmedPASS
amount_within_documented_lossPASS
fraud_screening_passedPASS
prompt_payment_compliancePASS
single_agent_authorization_limitPASS
timestamps
decision_resultEXECUTE
rationaleClaim BIC-2026-04471 approved under CP-BI-2023-v4. Coverage trigger confirmed. BI period 53 days validated. Fraud score 0.08. Prompt payment: Day 55, within 21-day window from Day 34.
inputs_captured_at2026-07-03T17:56:43Z
decision_made_at2026-07-03T17:56:46Z
receipt_sealed_at2026-07-03T21:19:54.578Z
snapshot_hash2cffe275339d2f44ca2f37e8a18370a4e54f3fd1a7ac4d01d4f59f2e5ae7a5a3
sealhmac-sha256:gde2BzjnNUiEAXm7nVc_zswYVUPun3GJsftG9YiLWyc
03 // LEGAL
AI Discovery Review
40,000 documents · privilege log · sanctions motion defense
Hartwell & Crane LLP's AI review agent classifies 40,000 documents for privilege and responsiveness. Each produce or withhold decision is sealed before the privilege log entry is generated. When opposing counsel files a sanctions motion alleging retroactive reclassification, the sealed timestamps prove the privilege determinations predate the challenge by two weeks.
Verifier: opposing counsel · federal judge in camera · special master
Read the case study →
SAMPLE RECEIPT: LEGAL DISCOVERY Verify live receipt →
seal_oktrue
agent_iddiscovery-review-agent-v4
operator_idhartwell-crane-llp
action_typeprivilege_review
ruleset_idprivilege-rules-sdny-v3
conditions_evaluated
attorney_client_communicationPASS
primary_purpose_legal_advicePASS
no_third_party_waiverPASS
work_product_doctrinePASS
timestamps
decision_resultHOLD
rationaleDOC-MCR-2021-004471: Attorney-client communication, CEO to GC. Work product doctrine applies. All 4 privilege conditions passed. Withheld from production.
inputs_captured_at2026-07-03T17:57:03Z
decision_made_at2026-07-03T17:57:05Z
receipt_sealed_at2026-07-03T21:20:36.359Z
snapshot_hash9f2d9fe587a63b9bad8f71f8b554508276ac11a48fc73007d697dd5b1b2f4af7
sealhmac-sha256:0zPX99m40rRdtSX-VgLUGlJ0ZIErPar9CuUZuBv8yaU
04 // TRADING
Algorithmic Execution
$4.2M ETH order · SEC examination · 347ms seal-to-submit
Arcturus Capital Management's AI execution agent fires a $4,218,500 ETH market buy, evaluating five pre-trade risk conditions against its FINRA-filed risk policy in 347 milliseconds. The receipt is sealed 56ms before the order reaches the exchange. Four months later, an SEC examiner verifies the pre-trade controls independently from the SEC's own network.
Verifier: SEC examiner · FINRA staff · CFTC investigator
Read the case study →
SAMPLE RECEIPT: ALGORITHMIC TRADING Verify live receipt →
seal_oktrue
agent_idexecution-agent-v8
operator_idarcturus-capital-management
action_typemarket_order_execution
ruleset_idexecution-risk-policy-v12
conditions_evaluated
single_trade_size_limitPASS
portfolio_drawdown_breakerPASS
volatility_halt_checkPASS
liquidity_adequacyPASS
signal_strength_thresholdPASS
timestamps
decision_resultEXECUTE
rationaleETH mean-reversion -3.2 std dev (threshold -2.5). All 5 pre-trade risk conditions passed. $4,218,500 BUY ETH/USD market, Coinbase.
inputs_captured_at2026-07-03T17:57:23.648Z
decision_made_at2026-07-03T17:57:23.857Z
receipt_sealed_at2026-07-03T21:21:02.218Z
snapshot_hash2b580d14e3598733dd11e3e14b1d93b7d1dc02a0c441c60beb1badc3362ea7f7
sealhmac-sha256:5wfYXuQy-afsVCv3wbSJYtGkNfTvsL-BrI0DbP8nobE
Live API Structure
Execute & verify
REQUEST: POST /api/execute/decision
// Seal a decision before execution POST https://api.proofrelay.app/api/execute/decision // Headers: Content-Type: application/json x-api-key: pr_live_xxxxxxxxxxxxxxxxxxxx // Body: { "agent": { "agent_id": "agent-procurement-v2", "operator_id": "acme-corp" }, "decision": { "action_type": "vendor_payment", "action_taken": true, "decision_result": "EXECUTE", "rationale": "Vendor approved, amount within policy threshold" }, "inputs": { "snapshot_fields": { "vendor": "Apex Logistics LLC", "amount_usd": 14200 }, "captured_at": "2026-07-03T12:00:00Z" }, "logic": { "ruleset_id": "procurement-policy-v3", "conditions_evaluated": [ { "condition": "vendor_approved", "result": "PASS" }, { "condition": "amount_within_limit", "result": "PASS" } ] }, "timestamps": { "inputs_captured_at": "2026-07-03T12:00:00Z", "decision_made_at": "2026-07-03T12:00:02Z" }, "reasoning_trace": { "redacted_summary": "Vendor approved, amount within policy threshold" } }
RESPONSE: 201 CREATED
{ "receipt_id": "b5a3f9fb-ca19-4dce-ace2-...", "status": "stored", "seal": "hmac-sha256:-c9fHsQRx5T5Rkez...", "inputs": { "snapshot_hash": "f54cb43bcaaec6a7..." }, "reasoning_trace": { "trace_hash": "5abb10344155d13d..." }, // raw reasoning_trace not stored, hash only "timestamps": { "receipt_sealed_at": "2026-07-03T21:19:01.247Z" }, "verification_url": "https://api.proofrelay.app/api/verify/decision?id=..." }
REQUEST: GET /api/verify/decision
// No API key required. Any counterparty can verify independently GET https://api.proofrelay.app/api/verify/decision?id=YOUR_RECEIPT_ID // That's it. No headers, no body, no auth. // Works in a browser, curl, or any HTTP client.
RESPONSE: 200 OK
{ "receipt_id": "6ce74f18-7839-4ae1-a891-...", "seal_ok": true, "agent_id": "agent-procurement-v2", "decision": "EXECUTE", "ruleset_id": "procurement-policy-v3", "ruleset_hash": "sha256:3f7a2b9c1d...", "snapshot_hash": "sha256:8e4c1a7f...", "sealed_at": "2026-03-13T14:32:07Z" }
STEP 1: VERIFY A LIVE RECEIPT (no API key required)
// Real sealed receipt from a demo treasury agent. // $2,412,500 wire to an approved vendor. Four policy conditions evaluated. EXECUTE. // Paste this in your terminal: curl -s \ "https://api.proofrelay.app/api/verify/decision?id=b5a3f9fb-ca19-4dce-ace2-f01183c09ad9" \ | python3 -m json.tool // Returns: { "seal_ok": true, "receipt_id": "b5a3f9fb-ca19-4dce-ace2-f01183c09ad9", "agent_id": "treasury-agent-v2", "decision": "EXECUTE" }
STEP 2: SUBMIT YOUR OWN RECEIPT (API key required)
// Get a free key: 50 receipts/month, no card required. // Then seal your first decision: curl -s -X POST \ "https://api.proofrelay.app/api/execute/decision" \ -H "x-api-key: YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "agent": { "agent_id": "your-agent-v1" }, "decision": { "action_type": "invoice_approval", "action_taken": true, "decision_result": "EXECUTE" }, "inputs": { "snapshot_fields": { "amount_usd": 4500, "limit_usd": 10000 }, "captured_at": "2026-07-03T12:00:00Z" }, "logic": { "ruleset_id": "policy-v1" }, "timestamps": { "inputs_captured_at": "2026-07-03T12:00:00Z", "decision_made_at": "2026-07-03T12:00:02Z" }, "reasoning_trace": { "redacted_summary": "Amount within policy threshold" } }' // Returns receipt_id + seal + a public verification URL. // Anyone can verify: /api/verify/decision?id=YOUR_RECEIPT_ID
What You Get
The integrity model
HASH

Atomic sealing

Inputs snapshot, policy ruleset, policy condition evaluation results, and reasoning trace are sealed as a single indivisible unit using HMAC-SHA-256. Modification of any field breaks the seal on recomputation.

TIME

Timestamps inside the seal

ISO 8601 timestamps are embedded in the hash itself, not a metadata field. You cannot backdate or forward-date a receipt without detection.

AGENT

AI agent native

Built for autonomous decision loops. Your agent seals the inputs, policy, and reasoning before acting, not after. Downstream agents and auditors see what the agent saw, what policy governed it, and what reasoning produced the decision.

API

Two-endpoint simplicity

POST to execute. GET to verify. No SDK required, no complex setup. Works with any HTTP client in any language. Production-ready in minutes.

KEY

Instant key issuance

Subscribe, and your API key arrives in seconds via automated email. No waiting, no sales calls, no approval queues. Start sealing actions immediately.

URL

No stored validity flags

Every receipt is publicly verifiable by any party using only the receipt ID. Verification recomputes the seal from stored fields rather than reading a stored flag, so tampering is detectable even if the database is compromised.

Use Cases
Who calls the API
01
AI Agent Audit Trails
Autonomous agents executing payments, approvals, or decisions call ProofRelay on each action. Creates a tamper-evident record no agent or operator can alter retroactively.
02
Financial Transaction Receipts
Seal payment authorizations, fund transfers, and trade confirmations. Cryptographic proof of exactly what was approved, by whom, at what time.
03
Compliance & Regulatory Proof
EU AI Act, SEC algorithmic decision guidance, HIPAA clinical decision support requirements, and FINRA algorithmic trading rules all require demonstrable proof of what an AI decided, under what policy, and when. ProofRelay provides execution-time evidence for exactly these proceedings, not reconstructed logs.
04
Enterprise Workflow Approvals
Procurement, vendor onboarding, credit decisions, content moderation. Anywhere a human used to sign off but an agent now acts. ProofRelay gives compliance teams the same evidentiary standard without slowing execution.
05
Multi-Agent Workflows
When agent A in system X authorizes agent B in system Y, seal each decision with parent/child receipt links. Reconstruct the full decision trail for incident review cryptographically, not from memory.
Developer Documentation
Quickstart
integration
Getting Started
Verification
Reference

Authentication

Authenticated requests pass your API key in the x-api-key header. Your key is issued automatically when you subscribe and emailed to you instantly.

Keys are prefixed pr_live_ for production. Keep your key secret. Treat it like a password. You can rotate it from the customer portal.

Base URL
BASE_URL = "https://api.proofrelay.app" // Execute endpoint requires: x-api-key: pr_live_xxxxxxxxxxxxxxxxxxxx Content-Type: application/json // Verify endpoint requires NO auth. Fully public: GET /api/verify/decision?id=YOUR_RECEIPT_ID

Execute: JavaScript

Call POST /api/execute/decision to seal a decision before it executes. Pass your agent ID, decision, ruleset, inputs snapshot, and reasoning trace. The response includes a receipt_id, the seal, and a public verification URL. Store the receipt ID.

Node.js / fetch
const response = await fetch('https://api.proofrelay.app/api/execute/decision', { method: 'POST', headers: { 'Content-Type': 'application/json', 'x-api-key': 'pr_live_xxxxxxxxxxxxxxxxxxxx' }, body: JSON.stringify({ agent: { agent_id: 'my-agent-v1' }, decision: { action_type: 'invoice_approval', action_taken: true, decision_result: 'EXECUTE', rationale: 'Amount within policy threshold' }, inputs: { snapshot_fields: { action: 'approve_invoice', amount: 4500.00 }, captured_at: new Date().toISOString() }, logic: { ruleset_id: 'policy-v1' }, timestamps: { inputs_captured_at: new Date().toISOString(), decision_made_at: new Date().toISOString() }, reasoning_trace: { redacted_summary: 'Amount within policy threshold' } }) }); const receipt = await response.json(); console.log(receipt.receipt_id); // receipt.receipt_id: store this, use it to verify later console.log(receipt.seal); // receipt.seal: the HMAC applied before execution

Execute: Python

Use the requests library or any HTTP client. The API is pure REST. No SDK required.

Python (requests)
import requests url = "https://api.proofrelay.app/api/execute/decision" headers = { "Content-Type": "application/json", "x-api-key": "pr_live_xxxxxxxxxxxxxxxxxxxx" } payload = { "agent": {"agent_id": "my-agent-v1"}, "decision": { "action_type": "invoice_approval", "action_taken": True, "decision_result": "EXECUTE", "rationale": "Amount within policy threshold" }, "inputs": { "snapshot_fields": {"action": "approve_invoice", "amount": 4500.00}, "captured_at": "2026-07-03T12:00:00Z" }, "logic": {"ruleset_id": "policy-v1"}, "timestamps": { "inputs_captured_at": "2026-07-03T12:00:00Z", "decision_made_at": "2026-07-03T12:00:02Z" }, "reasoning_trace": {"redacted_summary": "Amount within policy threshold"} } r = requests.post(url, json=payload, headers=headers) receipt = r.json() print(receipt["receipt_id"]) # store this print(receipt["seal"]) # sealed before execution

Verify: JavaScript

Call GET /api/verify/decision?id= with your receipt ID. No API key required. Any counterparty can run this independently. A response with seal_ok: true is your cryptographic proof the decision was untampered.

Node.js / fetch
const receiptId = 'YOUR_RECEIPT_ID'; const response = await fetch( `https://api.proofrelay.app/api/verify/decision?id=${receiptId}` ); const result = await response.json(); if (result.seal_ok) { console.log('✓ Seal verified. Decision record untampered.'); } else { console.log('✗ Receipt not found or seal broken'); }

Verify: Python

Simple GET request. No API key required. Pass the receipt_id you stored at execute time.

Python (requests)
import requests receipt_id = "YOUR_RECEIPT_ID" url = f"https://api.proofrelay.app/api/verify/decision?id={receipt_id}" r = requests.get(url) # no auth header needed result = r.json() if result["seal_ok"]: print("Seal verified. Decision record untampered.") else: print("Receipt not found or seal broken")

Response Schema

Execute returns a 201 Created. Verify returns a 200 OK. All responses are JSON.

Execute Response
{ "receipt_id": string, // UUID, store this for verification "status": "stored", "agent": object, // agent_id, operator_id, environment "decision": object, // action_type, decision_result, rationale "inputs": object, // snapshot_id, snapshot_hash, captured_at "logic": object, // ruleset_id, ruleset_hash "timestamps": object, // inputs_captured_at, decision_made_at, receipt_sealed_at "reasoning_trace": object, // trace_hash only, raw trace never stored "seal": string, // HMAC-SHA-256 over the canonical string "verification_url": string, // public, no auth required "graph_url": string // causal DAG traversal, also public }

The three-timestamp structure (inputs_captured_at, decision_made_at, and receipt_sealed_at) provides a cryptographically attested decision lifecycle sequence. Any verifier can confirm the temporal relationship between input capture, decision formation, and sealing.

Verify Response
{ "receipt_id": string, "found": boolean, "seal_ok": boolean, // Recomputed fresh at request time, never a stored flag "version": number, "receipt_type": "decision", "parent_receipt_id": string | null, "anchoring": object, "receipt": object // full stored decision context: agent_id, decision_result, // hashes, conditions_evaluated, all three timestamps, seal }

Error Codes

ProofRelay returns standard HTTP status codes with a JSON error body containing a code and message field.

Error Response Shape
{ "error": { "code": "INVALID_API_KEY", "message": "The provided API key is invalid or expired", "status": 401 } }
Status Codes
400 INVALID_PAYLOAD // Missing required fields 401 INVALID_API_KEY // Key missing, invalid, or revoked 402 SUBSCRIPTION_REQUIRED // No active subscription 404 RECEIPT_NOT_FOUND // receipt_id does not exist 429 RATE_LIMIT_EXCEEDED // Too many requests 500 INTERNAL_ERROR // Server error, contact support
Pricing
Pay for sealing, not verification
Monthly Annual 2 months free
Free · No Card Required
Free
$0/mo
50 receipts included per month
  • Execute endpoint
  • SHA-256 cryptographic sealing
  • API key delivered instantly
  • Public verification URLs
  • No credit card required
Start Free →
Pro · Live Now
Pro
$99/mo
5,000 receipts included per month
  • Everything in Starter
  • Webhook delivery: push receipts to your endpoint
  • HMAC-signed webhook payloads
  • Delivery audit log with auto-retry
  • Overage: $0.01 per additional receipt
Verification is public and unlimited. Plan limits apply to sealing only.

Verify a live receipt.

A real sealed receipt, one click away. No account, no API key, no operator trust required. When you're ready to seal your own decisions, the free tier includes 50 receipts a month with no card required.

Verify A Live Receipt → Get A Free API Key →
hello@proofrelay.app
PATENT PENDING · U.S. APPLICATION NO. 19/647,952