Verification Mark

Put the Verification Mark on your site

Bind the AI output you publish to a signed Intentrax proof, so readers with the browser extension see a green mark only while your page shows exactly the words the proof was issued for.

What your readers see

Green only for the exact words you signed.

The Intentrax browser extension checks any page that points to a proof. The mark turns green only when the proof verifies and the page’s marked text matches, character for character, the text sealed inside it. Anything else stays neutral.

Try it

  • The check runs in the reader’s browser, against the public verifier. Page text never leaves the browser.
  • Green needs both a valid proof and an exact text match.
  • An edited answer, a copied pointer or an unreachable verifier is never green.
https://www.intentrax.com/verification-mark/demo

Published answer

A page whose text is bound to a signed proof

Intentrax Verification Mark: first bound proof.

Intentrax Verification Mark: first bound proof!

This text is bound to a signed Intentrax proof. Change one character and the mark stops being green.

Verified by Intentrax

The marked content on this page is bound to a verified proof.

Intentrax proof available

A proof exists, but this page’s content is not confirmed bound to it. Page content differs from the proof’s bound output (possible copy-paste).

Execution / proof id
a39b62ee…7b3229
Output binding
confirmed — content bound to proof
MISMATCH — page content ≠ bound output
View independent proof

This verifies recorded execution facts and integrity. It does not judge whether the AI answer is correct, safe, or advisable.

Illustration of the Intentrax browser extension’s toolbar badge and popup, using its own labels and colours. The proof and the bound text are the live demo’s real production proof. See it on the real page.

Only one state is green.

Every other outcome is neutral or a warning, so the mark never vouches for words nobody signed. It fails closed: if anything is uncertain, it is not green.

  • Verified by IntentraxThe proof verifies and the page shows exactly the bound text. The only green state.Green
  • Intentrax proof availableA real proof, but this page’s text is not the text it was issued for, for example after an edit or a copy-paste.
  • Checking Intentrax proof…Verifying independently with verify.intentrax.com.
  • Proof not foundNo matching proof was found at the verifier.
  • Status unavailableThe verifier could not be reached. Unknown, not a failure, and never green.
  • Verification failedThe independent verifier could not confirm this proof.
Live in production · execute access is review-gated

Four steps to the green mark

Four steps: bind the text you will show to a signed proof, render that text in a marked region, point the page at the proof, and check it. A reader with the Intentrax browser extension then sees a green mark only while your page shows exactly the text the proof was issued for. The live demo is a working example of every step.

  1. Bind the output when you issue the proof

    Install @intentrax/sdk 1.3.0 or later. bindIntentExecuteOutput hashes the text you are about to render and turns your execute request into schema /1.1 with an output_binding. The engine seals that binding inside the signed proof, where nobody can change it later. The response returns the proof id as registry_proof_id.

    import { bindIntentExecuteOutput } from "@intentrax/sdk";
    import { executeIntentHttp } from "@intentrax/sdk/http";
    
    // Exactly the text your page will show inside its data-intentrax-output region.
    const renderedOutput = answer.text;
    
    const request = bindIntentExecuteOutput({
      schema_version: "intentrax.runtime.intent_execute.request/1.0",
      intent_id: "intent-answer-8812",
      tenant_id: process.env.INTENTRAX_TENANT_ID,
      action: "PUBLISH_BOUND_OUTPUT",
      idempotency_key: "answer-8812-v1",
      proof_chain_fixture_ref: "contracts/test_vectors/protocol/book1/proof_chain.golden.json",
    }, renderedOutput);
    // request is now schema /1.1 with an output_binding block (SHA-256 over the
    // intentrax-content/1.0 normalization of renderedOutput).
    
    // executeIntentHttp returns PASS whenever the transport returns, so the
    // transport must reject non-2xx responses itself: 403/423 (review-gated) and
    // every other engine refusal surface here, before registry_proof_id is read.
    const transport = async ({ method, url, headers, body }) => {
      const res = await fetch(url, { method, headers, body });
      const payload = await res.json();
      if (!res.ok) {
        throw new Error(`execute refused (HTTP ${res.status}): ${payload.error_code ?? "unknown error"}`);
      }
      return payload;
    };
    
    // options: base_url "https://api.intentrax.com" plus the execution key issued
    // with your tenant, loaded from your server's environment (option names: SDK README).
    const result = await executeIntentHttp(request, transport, options);
    if (result.status !== "PASS") throw new Error(result.error.message);
    const proofId = result.output.response.registry_proof_id;
  2. Render exactly that text in a marked region

    Wrap the output in one element carrying data-intentrax-output. The extension reads the region's visible text (innerText, never hidden text), so keep anything else out of it: a "Copy" button label inside the region would change the hash. Markup inside is fine; whitespace and line endings are normalized by intentrax-content/1.0. Several marked regions are joined in document order, each followed by a newline; bind them the same way by passing an array.

    <div data-intentrax-output>
      <!-- renderedOutput, exactly as bound: nothing more, nothing less -->
    </div>
  3. Point the page at the proof

    Add the pointer the extension looks for to the page's <head>. verificationPointerMetaTag builds it and refuses anything but an https verifier URL.

    import { verificationPointerMetaTag } from "@intentrax/sdk";
    
    const meta = verificationPointerMetaTag({
      proof_id: proofId,
      verify_url: `https://verify.intentrax.com/api/public/verify/proof/${proofId}`,
    });
    // Put meta in the page's <head>:
    // <meta name="intentrax-verification" content="proof_id=...;verify_url=...">
  4. Check it

    The public verifier must report the proof valid and the binding as coming from the signed proof:

    curl -s https://verify.intentrax.com/api/public/verify/proof/{proof_id}
    Expected in the response
    "verification": {
      "verification_status": "VALID",
      "can_assert_validity": true
    },
    "output_binding_status": "BOUND",
    "output_binding": {
      "content_hash": "{the hash bindIntentExecuteOutput computed}",
      "hash_algorithm": "SHA-256",
      "normalization": "intentrax-content/1.0",
      "source": "SIGNED_PROOF_RECORD"
    }

    Then open your page with the extension installed: the mark is green. Change one character of the marked text and it turns neutral.

Rules that keep the mark honest

  • One proof per rendered text. If the text changes (an edit, a regenerated answer, a translation), issue a new proof for the new text. The old proof stays valid for the old words only.
  • Copying never turns green. Another page that reuses your pointer with different text shows a neutral "proof available", never the green mark.
  • Binding, not truth. Green means these exact words are the ones the proof was issued for. It does not, on its own, show that what they say is true, correct or safe.
  • Fail closed. If the verifier cannot be reached, the mark is neutral ("status unavailable"), never green and never a false failure.

Access, honestly: reading and verifying proofs needs no account. Issuing proofs uses POST /v1/intents/execute with X-Intentrax-Api-Key and X-Intentrax-Tenant-Id, which is enabled per tenant after an architectural review; until then it answers HTTP 423 or 403. The browser extension is available for Chrome, Microsoft Edge and Firefox (desktop and Android).

Developer Path

See the mark live, then bind your own output

Start with the no-account action that fits this page; a free account opens the console, and the proof-generating sandbox is issued after a short architectural review.

On this page

What this page provides

  1. Bind at issuance

    The SDK hashes the text you are about to render and sends it with your execute request; the engine seals it inside the signed proof.

    • bindIntentExecuteOutput
    • Execute request /1.1
    • Sealed in the signed proof
  2. Mark and point

    Render the same text in a data-intentrax-output region and add one meta tag that points at the proof.

    • data-intentrax-output
    • intentrax-content/1.0
    • verificationPointerMetaTag
  3. Verified independently

    The extension fetches the verdict from verify.intentrax.com itself and compares hashes locally; page text never leaves the reader's browser.

    • Valid proof required
    • Exact text match required
    • Neutral on any change

Keep exploring

Recommended next steps

  1. 01Read the four stepsStart with public developer guidance, then request sandbox access through review.
  2. 02DocsKeep exploring the public site, no account required.
  3. 03QuickstartKeep exploring the public site, no account required.
  4. 04SDKsKeep exploring the public site, no account required.
  5. 05API ReferenceKeep exploring the public site, no account required.
  6. 06Agent ToolkitKeep exploring the public site, no account required.
  7. 07SandboxKeep exploring the public site, no account required.
  8. 08Intentrax LabsResearch, standards, and the AEVN Initiative, available as public resources.

Next step

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
Checked
  1. Request
  2. Recorded
  3. Signed