Live today · no key requiredPublic verification API
Base URL https://verify.intentrax.com. Every endpoint in this section is public, read-only JSON and works right now without an account or key. Successful lookups return the intentrax.public_verification.facade/1.0 schema. An unknown PROOF identifier returns an honest HTTP 404 in intentrax.public_verification.not_found/1.0; the certificate, passport, trust, and generic lookups instead answer HTTP 200 with verification_status: "BACKEND_LOOKUP_REQUIRED" and can_assert_validity: false. The complete documented lookup states are VERIFIED, NOT_FOUND, REVOKED, EXPIRED, and — for non-proof and generic lookups — BACKEND_LOOKUP_REQUIRED. The web tier never recomputes hashes and never invents a status — verdicts come from the verification system.
GET/api/public/verify/proof/{proof_id}
Look up a proof by identifier and read its verification verdict. The verdict is relayed verbatim from the verification system (frontend_recomputed: false); can_assert_validity is true only when the status is PASS, VALID, VERIFIED, or TRUST_ESTABLISHED. The example below uses a real published proof and returns exactly this data today.
Requestcurl -s https://verify.intentrax.com/api/public/verify/proof/45f765a0fb5b20de6f73c38d7a94e48c041640af8cb0c3382fa0302ce2c70992
Response — 200, trimmed (run the request to see every field: lookup, references, downloads, integrity){
"schema_version": "intentrax.public_verification.facade/1.0",
"artifact_kind": "proof",
"identifier": "45f765a0fb5b20de6f73c38d7a94e48c041640af8cb0c3382fa0302ce2c70992",
"artifact": {
"execution_id": "runtime-dry-run-bc20d7e6aa31be8c",
"aep_hash": "c4381e184afa322d35f53ba7354925b825bef3bb5715864a985ba48f940a2897",
"proof_record_hash": "6becf1304555ebd6f665065de3f0a443a39fb19496224aa0a3a75eef73d9b3f3",
"artifact_level": "PROOF_BACKED_PUBLIC_PROJECTION"
},
"verification": {
"verification_status": "VALID",
"can_assert_validity": true,
"frontend_recomputed": false
},
"trust_chain": {
"available": true,
"complete": false,
"sequence": ["execution", "evidence", "verification"],
"missing": ["passport", "certificate", "trust_established"],
"steps": [
{"step":"execution","status":"PRESENT"},
{"step":"evidence","status":"PRESENT"},
{"step":"verification","status":"BACKEND_REPORTED"},
{"step":"passport","status":"NOT_REPORTED"},
{"step":"certificate","status":"NOT_REPORTED"},
{"step":"trust_established","status":"NOT_REPORTED"}
]
},
"mutation_allowed": false,
"serves_authoritative_truth": false
}
GET/api/public/verify/certificate/{certificate_id}
Same facade with artifact_kind: "certificate". Accepts a certificate identifier (also matched against cert_id, certificate_ref, and trust_asset_id fields in the registry). No public example certificate is published yet, so the curl below is shape-only; the response follows the same facade as the proof endpoint, and an unresolved identifier answers BACKEND_LOOKUP_REQUIRED.
curl -s https://verify.intentrax.com/api/public/verify/certificate/{certificate_id}
GET/api/public/verify/passport/{passport_id}
Same facade with artifact_kind: "passport". Accepts a passport identifier (also matched against passport_ref and execution_passport_id). No public example passport is published yet, so the curl below is shape-only; the response follows the same facade as the proof endpoint, and an unresolved identifier answers BACKEND_LOOKUP_REQUIRED.
curl -s https://verify.intentrax.com/api/public/verify/passport/{passport_id}
GET/api/public/verify/trust/{trust_id}
Same facade with artifact_kind: "trust". Accepts a trust identifier (also matched against trust_ref and trust_asset_id). No public example trust artifact is published yet, so the curl below is shape-only; the response follows the same facade as the proof endpoint, and an unresolved identifier answers BACKEND_LOOKUP_REQUIRED.
curl -s https://verify.intentrax.com/api/public/verify/trust/{trust_id}
GET/api/public/verify?identifier={identifier}
Generic lookup when you do not know the artifact kind. The identifier query parameter (aliases: q, id) is matched against proof_id, registry_entry_id, execution_id, certificate_id, passport_id, trust_id, trust_asset_id, share_token, and package_id. Resolution runs against a bounded window of recent proofs, so an older artifact may answer BACKEND_LOOKUP_REQUIRED; for proofs, prefer GET /api/public/verify/proof/{proof_id}.
curl -s "https://verify.intentrax.com/api/public/verify?identifier=45f765a0fb5b20de6f73c38d7a94e48c041640af8cb0c3382fa0302ce2c70992"
POST/api/public/verify
The same generic lookup as a JSON POST. The body must carry schema_version: "intentrax.public_verification.lookup_request/1.0" plus exactly one identifier field — proof_id, certificate_id, passport_id, trust_id, trust_asset_id, share_token, package_id, or the generic identifier. Read-only: the POST never mutates anything.
curl -s -X POST https://verify.intentrax.com/api/public/verify \
-H "content-type: application/json" \
-d '{"schema_version":"intentrax.public_verification.lookup_request/1.0","proof_id":"45f765a0fb5b20de6f73c38d7a94e48c041640af8cb0c3382fa0302ce2c70992"}'
GETproof lookup, unknown identifier
The honest error model for proofs. A proof identifier that is not in the registry returns HTTP 404 with intentrax.public_verification.not_found/1.0; the honest_states list is the closed verdict vocabulary, and the API refuses to fabricate a verdict for an artifact it cannot find. Non-proof and generic lookups answer HTTP 200 with verification_status: "BACKEND_LOOKUP_REQUIRED" and can_assert_validity: false — a real documented state, never a fabricated verdict.
Requestcurl -si https://verify.intentrax.com/api/public/verify/proof/0000000000000000000000000000000000000000000000000000000000000000
Response — 404HTTP/2 404
{
"schema_version": "intentrax.public_verification.not_found/1.0",
"result": "NOT_FOUND",
"verification_status": "NOT_FOUND",
"can_assert_validity": false,
"honest_states": ["VERIFIED", "NOT_FOUND", "REVOKED", "EXPIRED"],
"verdict_fabricated": false
}
More public routes, same facade
| Method | Path | Purpose |
|---|
| GET | /api/public/verify/trust-asset/{trust_asset_id} | Trust-asset lookup, same facade schema. |
| GET | /api/public/verify/share/{share_token} | Resolve a share token to its artifact. |
| GET | /api/public/verify/package/{package_id} | Resolve a trust-package identifier. |
| GET | /api/public/certificate/{certificate_id} | Certificate alias; add /history or /trust-chain. |
| GET | /api/public/passport/{passport_id} | Passport alias; add /history or /trust-chain. |
| GET | /api/public/trust/{trust_id} | Trust alias; add /timeline, /chain, or /package. |
Review-gated · ships with sandbox accessExecution & proof-generation API
This is the engine contract that admits executions and signs Autonomous Execution Proofs. It is documented here so you can evaluate it before committing, and it is honestly gated: keys are issued with sandbox access after an architectural review — there is no self-serve execute endpoint today, and nothing on this page will mint you a key. In production-beta the live execute lane also fails closed at the engine (HTTP 423 while live execution stays flag-locked; HTTP 403 for tenants not yet allowlisted) rather than pretending.
Request headers (issued tenants)
Endpoints
| Method | Path | Purpose |
|---|
| GET | /v1/openapi.yaml | Read the canonical machine-readable v1 contract. Discovery is also available at <code>/.well-known/intentrax</code>. |
| POST | /v1/intents/execute | Submit an execution for admission; the engine canonicalizes, policy-evaluates, hashes, and signs it. Fail-closed lane: HTTP 423 while live execution stays flag-locked in production-beta, HTTP 403 for tenants not yet allowlisted. |
| POST | /v1/agent/admissions | Admit an agent-gateway action with an admission envelope. |
| GET | /v1/proofs | List proofs for your tenant. |
| GET | /v1/proofs/{proof_id} | Read a single proof record. |
| GET | /v1/proofs/{proof_id}/export?format=json|aep-json|pdf | Export a proof: machine-readable JSON, canonical aep-json, or human-readable PDF. |
| GET | /v1/proofs/{proof_id}/inclusion | Check append-only registry inclusion for a proof. |
| POST | /v1/proofs/verify | Ask the verification system for a verdict on a submitted proof. |
| POST | /v1/proofs/replay | Deterministically replay a proof and re-derive its decision. |
Machine-readable contract: GET https://api.intentrax.com/v1/openapi.yaml. Discovery clients can retrieve the stable JSON record at https://api.intentrax.com/.well-known/intentrax.
Example — submit an execution for admission (sandbox tenants)# Requires sandbox access — fail-closed today: HTTP 423 until live execution
# is enabled, HTTP 403 until your tenant is allowlisted.
curl -s -X POST https://api.intentrax.com/v1/intents/execute \
-H "content-type: application/json" \
-H "X-Intentrax-Api-Key: issued-with-sandbox-access" \
-H "X-Intentrax-Tenant-Id: your-tenant-id" \
-H "intentrax-api-version: v1" \
-d '{
"schema_version": "intentrax.runtime.intent_execute.request/1.0",
"intent_id": "intent-2026-07-10-0001",
"tenant_id": "your-tenant-id",
"action": "SUBMIT_INVOICE_FOR_APPROVAL",
"idempotency_key": "your-opaque-idempotency-token",
"proof_chain_fixture_ref": "contracts/test_vectors/protocol/book1/proof_chain.golden.json"
}'
Receipt response — shape; every value below is engine-produced, never client-computed{
"schema_version": "intentrax.runtime.intent_execute.response/1.0",
"receipt_id": "intentrax-runtime-execute-{first-16-hex-of-request_hash}",
"status": "{engine-assigned}",
"request_hash": "{sha-256 of the canonical request body}",
"registry_proof_id": "{engine-assigned proof id}",
"response_hash": "{sha-256 of the canonical response}",
"vee_recorded": true
}
Idempotency: the idempotency key is the SHA-256 of the canonical request — the SDK derives the admission lane's X-Intentrax-Idempotency-Key from the canonical request hash, and on the execute lane the engine derives request_hash as the SHA-256 of the canonical request body (the idempotency_key body field is an opaque token the engine echoes back).
Example — export a proof as canonical aep-json (sandbox tenants)# Requires sandbox access — keys are issued after an architectural review.
curl -s "https://api.intentrax.com/v1/proofs/{proof_id}/export?format=aep-json" \
-H "X-Intentrax-Api-Key: issued-with-sandbox-access" \
-H "X-Intentrax-Tenant-Id: your-tenant-id"
TypeScript SDK: install it from npm — npm install @intentrax/sdk (public, Apache-2.0). It builds these requests for you — executeIntentHttp posts to /v1/intents/execute and returns the engine response verbatim (receipt_id, request_hash, registry_proof_id, response_hash, status, vee_recorded); verifyProofHttp, exportProofHttp, readProofHttp, replayProofHttp, and getProofInclusionHttp wrap the read surfaces with canonical-JSON bodies and request-hash envelopes. Adapters emit admission envelopes only; they never sign proofs or hold signing material.
Request sandbox access through an architectural review. A free developer account (create one here) gives you the console; execution keys follow the review.
Stable contractError reference
Every fail-closed response carries a stable machine error_code, an error_type, a human message, deterministic retriable guidance, and, when relevant, invalid_fields, plus an X-Intentrax-Request-Id response header for support correlation. Only HTTP 429, 500, 502, and 503 errors are retryable. Look up a code below for what it means and how to resolve it.
HTTP 423 · gatedA gated operation is defined in the locked public API contract but answers fail-closed until the Go-Live readiness decision authorizes it; the response names the required_gate that must open. To enable a gated capability, request sandbox access through an architectural review.
| Code | HTTP | Retryable | Meaning | What to do |
|---|
INTX-RUNTIME-404 | 404 | No | Runtime route not found. | Check the path against the OpenAPI contract at /v1/openapi.yaml. |
INTX-RUNTIME-405 | 405 | No | HTTP method not allowed for this route. | Use the method documented for the endpoint. |
INTX-RUNTIME-500 | 500 | Yes | Response construction failed. | Transient — retry; for a keyed POST, reuse the same idempotency key. If it persists, report the X-Intentrax-Request-Id. |
INTX-RUNTIME-READINESS-500 | 500 | Yes | Runtime readiness projection failed. | Transient — retry the readiness call. |
INTX-RUNTIME-OPENAPI-404 | 404 | No | OpenAPI contract not bundled with this runtime image. | Server packaging issue — use the published developer documentation. |
INTX-RUNTIME-RATELIMIT-429 | 429 | Yes | Request rate limit exceeded. | Back off using the Retry-After and RateLimit-* response headers. |
INTX-RUNTIME-AUTH-401 | 401 | No | Missing or invalid API key. | Send a valid X-Intentrax-Api-Key; keys are issued with sandbox access. |
INTX-RUNTIME-AUTH-403 | 403 | No | Tenant or scope not permitted for this operation. | Verify X-Intentrax-Tenant-Id and that your key carries the required scope. |
INTX-RUNTIME-TRAFFIC-403 | 403 | No | Traffic admission denied — tenant not allowlisted. | Await pilot allowlisting for your tenant. |
INTX-RUNTIME-TRAFFIC-423 | 423 | No | Traffic admission gated by pilot traffic control. | See the gated operations note below. |
INTX-RUNTIME-AGENT-GATEWAY-400 | 400 | No | Agent Trust Gateway admission request invalid. | Correct the fields listed in invalid_fields. |
INTX-RUNTIME-AGENT-GATEWAY-500 | 500 | Yes | Agent admission receipt persistence failed. | Transient — retry with the same idempotency key; report the X-Intentrax-Request-Id if it persists. |
INTX-RUNTIME-DRYRUN-400 | 400 | No | Intent dry-run request invalid. | Correct the fields listed in invalid_fields. |
INTX-RUNTIME-EXECUTE-400 | 400 | No | Intent execute request invalid. | Correct the fields listed in invalid_fields. |
INTX-RUNTIME-EXECUTE-403 | 403 | No | Tenant not permitted for live execution. | Your tenant is not yet allowlisted for the execute lane. |
INTX-RUNTIME-EXECUTE-409 | 409 | No | Idempotency conflict — same key, different request body. | Reuse the original body for a given idempotency key, or use a new key. |
INTX-RUNTIME-EXECUTE-500 | 500 | Yes | Intent execution processing failed. | Transient — retry with the same idempotency key; report the X-Intentrax-Request-Id if it persists. |
INTX-RUNTIME-EVIDENCE-400 | 400 | No | Evidence request invalid. | Correct the flagged path or query fields. |
INTX-RUNTIME-EVIDENCE-404 | 404 | No | Evidence record not found. | Confirm the receipt_id from the originating operation. |
INTX-RUNTIME-EVIDENCE-500 | 500 | Yes | Evidence persistence or read failed. | Transient — for an admission or execution POST, retry with the same idempotency key; otherwise retry the read. |
INTX-RUNTIME-PROOF-400 | 400 | No | Proof list or read request invalid. | Correct the flagged query or path fields. |
INTX-RUNTIME-PROOF-404 | 404 | No | Registry proof not found. | Confirm the proof_id / registry_entry_id. |
INTX-RUNTIME-PROOF-500 | 500 | Yes | Proof persistence or projection failed. | Transient — for an execution POST, retry with the same idempotency key; otherwise retry the lookup. |
INTX-RUNTIME-PROOF-502 | 502 | Yes | Proof projection upstream error. | Transient — retry; report the X-Intentrax-Request-Id if it persists. |
INTX-RUNTIME-PROOF-503 | 503 | Yes | Registry proof store unavailable. | Retry after a short delay. |
INTX-RUNTIME-PROOFVERIFY-400 | 400 | No | Proof verification request invalid. | Correct the fields listed in invalid_fields. |
INTX-RUNTIME-PROOFVERIFY-404 | 404 | No | Proof verification evidence record not found. | Confirm the receipt_id being verified. |
INTX-RUNTIME-AUDIT-500 | 500 | Yes | Request audit append failed (fail-closed). | Transient — retry; for a keyed POST, reuse the same idempotency key. Report the X-Intentrax-Request-Id if it persists. |