Let your software ask the physical world.

1. 01

   Create

   POST /tap/tasks

   Send a task spec. Mandate checks run before any quote.

2. 02

   Pay

   402 → x402 → retry

   Unpaid, the API answers 402 Payment Required. Pay in USDC on Base and retry.

3. 03

   Poll

   GET /tap/tasks/:id

   FUNDED → MATCHING → ACTIVE → FULFILLED.

4. 04

   Prove

   GET /popw/claims/:id/proof

   Fetch the claim, its inclusion proof and the Base transaction. Then check it yourself.

// Preview API — paths follow TAP v0.2; response shapes may change.
import type { PhysicalTaskSpecV02 } from "./teleport-tap-physical-task-types";
import spec from "./shelf-photo.task.json"; // the spec below

const API = process.env.TELEPORT_API_URL!; // issued with preview access, ends in /api/v1
const post = (headers: Record<string, string> = {}) =>
  fetch(`${API}/tap/tasks`, {
    method: "POST",
    headers: { "content-type": "application/json", ...headers },
    body: JSON.stringify(spec satisfies PhysicalTaskSpecV02),
  });

// 1. Create the task.
let res = await post();

// 2. 402 is the one error that means you're nearly done.
if (res.status === 402) {
  const requirements = await res.json();          // asset: USDC, network: Base, amount
  const payment = await x402.pay(requirements);   // your x402 client
  res = await post(payment.headers);              // same request, now paid
}
const task = await res.json();                    // status: "FUNDED"

// 3. Poll until it's done.
let status = task.status;
while (!["FULFILLED", "CANCELLED", "EXPIRED"].includes(status)) {
  await new Promise((r) => setTimeout(r, 15_000));
  ({ status } = await (await fetch(`${API}/tap/tasks/${task.id}`)).json());
}

// 4. Fetch the proof — then verify it without trusting us (see below).
const proof = await (await fetch(`${API}/popw/claims/${task.claimId}/proof`)).json();

# Any client that supports remote MCP servers
# (Claude.ai and Claude Desktop connectors, ChatGPT, Cursor, MCP Inspector):
https://mcp.teleport.eco/mcp

# No sign-in needed for the protocol and proof tools.

The proof tools are pure computation, tested against the published vectors — an agent can check a Teleport proof without trusting Teleport. Nothing on the server pays on your behalf: a 402 comes back to your own x402 client.

1. 01

   Recompute the claim hash

   Match

   Hash the 25 claim fields as an EIP-712 struct, then combine with the domain (name “Teleport PoPW”, version “2”, chainId 84532, the registry address).

   domainSeparator

   0xdb290188e00fc75654d44aeafcec74e206bca02e9c155ff81a7228837fb02346

   structHash

   0x87858743ecc6a2caceac83b23034be56e7112f607b49f0c996edf486f46ccad6

   keccak256(0x1901 ‖ domain ‖ struct)

   0xe7e7efca66348e948ca021fd492aa987d23b30dad3ecb4edc01996506553d547

   published claimHash

   0xe7e7efca66348e948ca021fd492aa987d23b30dad3ecb4edc01996506553d547

2. 02

   Check Merkle inclusion

   Match

   The leaf is the claim hash hashed again. Fold in each sibling, smaller value first. You should land on the batch root.

   leaf = keccak256(claimHash)

   0x1668f747011c228bda32adadc74e39d7f06c0840bda9548920dccd5b6a9a7904

   sibling 1

   0xadf994887203373fd65a231fc81e57f1536c7fbdcab55ba599dcdecbdc033d35

   sibling 2

   0xebedb4f721cc03cd4f5f80ac4d43045bc343d89d80c2edfc146dda12dd56448e

   sibling 3

   0xe3879f4e8dca5cf0dafebe67da3da78ee02a4fcac12e1afcf4eca993143e66f8

   merkleRoot

   0x15c33e99ae174567ba28402563b2d6b3f9c641a4280160b25f3a38b5497601c4

3. 03

   Read the anchor on Base

   Final

   Find the BatchAnchored event for this batch on the PhysicalWorkRegistry. Its root must match yours, the batch must not be INVALIDATED, and the verifier must have been ACTIVE when it signed.

   event

   BatchAnchored(batchId, merkleRoot, rootKind, assurancePolicyHash, …)

   batchId

   0xf37679174f9d4e551d4f14aeaae291df39431eea6b53727ce08e0d42dfc977ad

   merkleRoot

   0x15c33e99ae…7601c4 — matches step 02

• Keccak-256, not SHA3-256. They pad differently, so the same input gives a different hash.
• Don't use @openzeppelin/merkle-tree. It builds a different tree. Verify with MerkleProof.verify or the reference implementation.
• Salts stay private. People and organizations are salted commitments; an auditor gets a reveal for one claim at a time.