IntentraxRequest Architectural Review
Menu

Quickstart

Verify a real proof in one command

Start where the platform is already public: verify a live, signed Autonomous Execution Proof with a single keyless curl against the public verification API, then request sandbox access to generate proofs of your own.

Read the API referenceExplore developersFor Developers

Developer path

Step 1 works right now with no account. The SDK is public on npm today; proof generation is review-gated, and execution keys arrive with sandbox access after an architectural review.

Read the trust model
Step 1 works right now · no account

Quickstart: verify first, then build

These steps use the live public verification API and a real published proof. Nothing below asks you to run a command that does not work today, and the review-gated parts say so.

  1. Verify a real, signed proof — one keyless curl

    This proof identifier is published and resolves on the live API:

    curl -s https://verify.intentrax.com/api/public/verify/proof/45f765a0fb5b20de6f73c38d7a94e48c041640af8cb0c3382fa0302ce2c70992
    Expected in the response
    "verification": {
  "verification_status": "VALID",
  "can_assert_validity": true,
  "frontend_recomputed": false
}

  2. Check that the API refuses to fabricate

    Look up a proof identifier that does not exist. You get an honest HTTP 404 with a closed verdict vocabulary — never an invented status:

    curl -si https://verify.intentrax.com/api/public/verify/proof/0000000000000000000000000000000000000000000000000000000000000000
    Expected
    HTTP/2 404

"schema_version": "intentrax.public_verification.not_found/1.0",
"result": "NOT_FOUND",
"honest_states": ["VERIFIED", "NOT_FOUND", "REVOKED", "EXPIRED"]

  3. See the same verdict as a human page

    Open the live verifier with the step-1 proof already loaded — no hash to hand-paste. The page reads the same registry the JSON API reads.

  4. Create a free developer account

    Sign up for the console. This gives you the developer surfaces; it does not create production credentials.

  5. Request sandbox access for the execute path — review-gated

    Generating proofs of your own means the engine's execution API: POST /v1/intents/execute and POST /v1/agent/admissions, with X-Intentrax-Api-Key and X-Intentrax-Tenant-Id headers, plus proof read, export (json, aep-json, pdf), inclusion, and replay under /v1/proofs. The SDK is public on npm today (npm install @intentrax/sdk) — install it now and use it against the live public verify API. Execution keys arrive with sandbox access after an architectural review; until then the execute lane answers fail-closed (HTTP 423/403). The full contract is on the API reference.

Honest time budget: your first verification takes under a minute from right now, with no account. Your first self-generated proof is not instant — it follows sandbox issuance, which follows an architectural review. We would rather tell you that here than after a signup.

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

Verify first

The public verification API is live, so your first verification takes one curl and under a minute — the numbered steps below use a real published proof identifier.

  • One keyless curl
  • Real signed proof
  • Under a minute

Trust the refusal

The same API answers an unknown proof identifier with an honest HTTP 404 and a closed vocabulary of verdict states — it never fabricates a result.

  • Honest NOT_FOUND
  • Closed state vocabulary
  • No fabricated verdicts

Then generate your own

The execute path — admission envelopes in, signed Autonomous Execution Proofs out — is review-gated; the SDK is public on npm today, and execution keys and the /v1 endpoints unlock with sandbox access after review.

  • Review-gated sandbox
  • Admission envelope contract
  • SDK public on npm

Recommended next steps

Read the API reference

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

Read the API reference
// 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

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