API Reference

The Intentrax API reference

The public verification API is live and keyless — every endpoint below is documented with a copy-pasteable curl and a real response. The execution API that generates proofs is documented with its real gating.

Open the sandbox path Explore developers For Developers

Developer path

Everything on this page traces to the shipped contract. The public verification API works today with no account; execution and proof-generation endpoints are review-gated and arrive with sandbox access.

Read the trust model

Live today · no key required

Public 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.

Request

curl -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,
    "sequence": ["execution", "evidence", "verification",
                 "passport", "certificate", "trust_established"]
  },
  "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.

Request

curl -si https://verify.intentrax.com/api/public/verify/proof/0000000000000000000000000000000000000000000000000000000000000000

Response — 404

HTTP/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 access

Execution & 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)

X-Intentrax-Api-Key — your engine key. Issued with sandbox access; never created by this website.
X-Intentrax-Tenant-Id — your tenant identifier, sent on tenant-scoped calls.
X-Intentrax-Idempotency-Key — idempotency for admission POSTs; the SDK derives it from the canonical request hash.
intentrax-api-version: v1 — the current contract version.

Endpoints

Method	Path	Purpose
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.

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.

Developer Path

Move from documentation to a reviewed developer sandbox

Read the public docs and verify a live proof today; a free account opens the console, and the proof-generating sandbox is issued after a short architectural review.

Create developer accountThe console workspace is free and opens at signup; the proof-generating sandbox is issued after a short architectural review.Start quickstartBuild the first verification flow from public docs.Read the API referenceEndpoint-by-endpoint: the live public verification API plus the review-gated execution contract.Verify a live proofOpen the public verifier and check a real example proof yourself — no account needed.

What this page provides

Public verification API

Look up any published proof, certificate, passport, or trust artifact by identifier and read the verification verdict as JSON — live today, no key, no account.

GET and POST lookup endpoints
Facade schema 1.0 responses
Honest 404 and BACKEND_LOOKUP_REQUIRED

Execution API, honestly gated

The engine contract that admits executions and signs Autonomous Execution Proofs is documented below, including the fail-closed statuses you will see before sandbox issuance.

POST /v1/intents/execute
Signed AEP out
Review-gated keys

Exports and replay

Issued tenants read, list, export, check inclusion, verify, and replay proofs through the /v1/proofs surfaces documented below.

JSON and aep-json
Human-readable PDF
Deterministic replay

Recommended next steps

Open the sandbox path

Start with public developer guidance, then request sandbox access through review.

Open the sandbox path

// Verify a real, signed proof — keyless, works right now:curl -s https://verify.intentrax.com/api/public/verify/proof/45f765a0fb5b20de6f73c38d7a94e48c041640af8cb0c3382fa0302ce2c70992"verification_status": "VALID"// npm install @intentrax/sdk

Keep exploring the public site — no account required.

Quickstart SDKs Sandbox

Intentrax Labs

Research, standards, and the AEVN Initiative remain available as public resources.

Explore Intentrax Labs

Build toward a reviewed sandbox path

Nothing you do here is published. The docs are public to read; your sandbox work stays private to your account, and production access is review-gated.

Request Architectural Review

The Intentrax API reference

Developer path

Public verification API

More public routes, same facade

Execution & proof-generation API

Request headers (issued tenants)

Endpoints

Move from documentation to a reviewed developer sandbox

What this page provides

Public verification API

Execution API, honestly gated

Exports and replay

Recommended next steps

Open the sandbox path

Related pages

Intentrax Labs

Build toward a reviewed sandbox path