Choose the hosted service you need.

Recall – read-only

A hosted MCP endpoint at mcp.whitemagic.dev/mcp (streamable-http) serves recall over a curated public corpus: docs, spec, release notes, and the grimoire. Keyless initialize / tools/list for directory probes; an anonymous free tier (3 calls/day per client IP, no key and no header); free evaluation keys are instant at mcp.whitemagic.dev/keys (50 recalls/day, no account, email optional); OAuth 2.1 for clients that speak it. Prefer local? Follow the version-pinned installation guide for the full local write path. Your local store is never uploaded.

Hosted memory – write beta (next lane)

The experimental lane at next.mcp.whitemagic.dev/mcp adds an invitation-only write beta beside the read-only corpus: write-scoped keys get an isolated per-tenant store, and their reads fuse tenant + corpus results with partition: tenant | corpus labels. Write scope reaches evaluation keys as a daily sample (20 writes / 1 MB) and x402 task-and-above leases as a per-payer daily budget (500 writes / 10 MB). Quotas, a per-key write rate limit, a lane-wide daily budget, and a disk guard bound every path; refusals are audited content-free. Tenant control: GET /tenant/export and DELETE /tenant?confirm=1 on the next-lane host with the tenant's key. The tenant plan ($5/mo per 128 MB, including 10,000 write ops/mo, extra $1/10,000) is the published direction while the beta opens; the read-only primary lane is unchanged.

Verify, anchors, receipts

A stateless verification API at api.whitemagic.dev: keyless /health, /info, and /openapi.json; keyed /verify (bundle → verdict, optional signed verification receipt), /verify-receipt, /verify-anchor, and /anchors (OpenTimestamps proof hosting; keyless fetch at /anchors/<digest>). The service metadata snapshot reviewed 2026-11-07 reports verifier 0.5.1 and support for continuity-receipt specs 0.1–0.6; the OpenAPI contract is contract revision 0.4.1 (20 paths covering verification, AER1 checks, anchors, payment receipts, notarization, Memory Crystals, and the ERC-8004 outcome adapter). The keyless POST /aer1/verify reports separate structural and identity verdicts for the AER1 draft 22 profile. Check current /info metadata before integration. The format and five-minute walkthrough are on the trust and receipts pages, and the verification explorer runs the checks in your browser.

Proof-of-Context notarization

An audit trail for agent decisions: POST /notarize signs the caller's supplied context digest or prompt hash together with bounded claims — the action label, model identifier, optional metadata, and the caller's agent address — and returns an Ed25519 attestation under a tamper-evident UTC timestamp. Retrieval is keyless at GET /notarize/<digest>. The service does not observe the underlying context or execution; it attests what the caller supplied, not that the claim is true. For POST /notarize, check current service metadata and access requirements before integrating.

# Python (whitemagic-pay)
receipt = client.notarize_context(
    context_digest="sha256:...",   # or prompt_hash
    action="agent.decision",
    model="gemini-2.5-flash",
    metadata={"epoch": 1},
)

// TypeScript
const receipt = await client.notarizeContext({ contextDigest: "sha256:...", action: "agent.decision" });

Evaluation endpoint

Add / Search / Delete over a participant-isolated store for evaluation harnesses: api.whitemagic.dev/eval (keyless health at /eval/health; access token on request; eval-only infrastructure, no SLA).

ERC-8004 Task-Outcome Validation

The hosted adapter at api.whitemagic.dev/erc8004/validate maps the core receipt-verifier verdict plus task binding to an outcome: TRUSTED → ACCEPT, PROVISIONAL → NEEDS_EVIDENCE, and UNTRUSTED → REJECT. Issuer policy is not evaluated and anchors are not required. Its chain_integrity, signatures_valid,policy_compliant, resource_caps_respected, and anchors_verifiedfields are null (unreported). It returns an Ed25519-signed canonical JSON statement; that signature is not independent proof of the task facts. The service does not submit statements onchain or settle transactions. See the live API info. Calls use x402; the published endpoint price is summarized above.

Client-Encrypted Memory Crystals

Client-encrypted agent-state storage at api.whitemagic.dev/crystals. State payloads are encrypted client-side using ChaCha20-Poly1305 AEAD, which protects plaintext while the keys remain with the client. The service stores ciphertext addressed by a SHA-256 object ID. All reads and writes require an authenticated owner assertion mapped through the explicit owner registry; payment or a session pass alone does not establish ownership. Owner assignment is manual, with no automatic first-reader claim or self-service mapping flow. Existing unmapped legacy data remains held in protected quarantine until an explicit operator mapping is confirmed. If you need help with an existing unmapped crystal, use the contact page to request an ownership review. Do not send plaintext, encryption keys, or bearer credentials. For an already-mapped owner, GET /crystals/owner-locator returns the registry-mapped locator. The wm-crystal/1.0 envelope is preserved. Reads and lineage remain free and require authenticated owner scope. Reads use Cache-Control: private, no-store. Conditional ETag/304 responses are available only after owner authentication; no shared caching. Lineage uses authenticated owner scope at GET /crystals/lineage; writes remain gated via x402 at the published write price summarized above. The /info metadata declares a crystal-specific maximum size of 2 MiB; the general API body limit is 1 MiB; the crystal route has its own 2 MiB cap. See the live API info and OpenAPI contract.

Metering and keys

Metered calls settle per call in USDC on Base via x402: a keyless call to a keyed method answers HTTP 402 with the payment requirements in the challenge – no account, no invoice. Free evaluation keys stay free (50 recalls/day, email optional), an anonymous free tier covers 3 calls/day with no key at all, and per-contract keys carry higher caps and metered audit lines. For scopes and terms, see Enterprise engagements or contact.

x402 quickstart

A method using x402 returns its payment requirement in HTTP 402, mirrored in the base64 PAYMENT-REQUIRED header. The captured /mcp challenge declared the call, task, swarm, and day lease tiers shown above; it was not a paid execution. The first paid call on a payer wallet also returns a welcome session pass (header X-Session-Pass and the tool result); reuse it to skip per-call payment.

Prefer a client library? The open-source whitemagic-pay SDK negotiates the challenge, signs the permit, caches the lease, and retries in one call — and it claims the free faucet pass with no wallet. PyPI · npm · source

pip install whitemagic-pay        # Python
npm install whitemagic-pay        # TypeScript

# Python
from whitemagic_pay import X402Client
client = X402Client(private_key="0xYOUR_FUNDED_BASE_KEY", preferred_tier="task")
status, data, headers = client.request("POST", "https://mcp.whitemagic.dev/mcp", data={...})

// TypeScript
import { X402Client } from "whitemagic-pay";
const client = new X402Client({ privateKey: process.env.AGENT_WALLET_KEY, preferredTier: "task" });
const { status, data } = await client.request("POST", "https://mcp.whitemagic.dev/mcp", { ... });

# No wallet yet? The faucet grants a free 10-minute pass:
client.claim_faucet("https://mcp.whitemagic.dev")   # Python
await client.claimFaucet("https://mcp.whitemagic.dev"); // TypeScript

Manual payer (Python, eth-account): sign an EIP-3009 authorization for the challenge and retry with the base64 payload.

python3 - <<'PY'
import base64, json, secrets, time, urllib.request, urllib.error
from eth_account import Account
from eth_account.messages import encode_typed_data

URL = "https://mcp.whitemagic.dev/mcp"
acct = Account.from_key("0xYOUR_FUNDED_BASE_KEY")

body = {"jsonrpc": "2.0", "id": 1, "method": "tools/call",
        "params": {"name": "memory.search",
                   "arguments": {"query": "recall where we left off"}}}
req = urllib.request.Request(URL, data=json.dumps(body).encode(),
                             headers={"Content-Type": "application/json"})
try:
    urllib.request.urlopen(req)
except urllib.error.HTTPError as e:
    challenge = json.loads(e.read())

tier = challenge["accepts"][0]        # $0.002 call; [1..3] = task/swarm/day
now = int(time.time())
auth = {"from": acct.address, "to": tier["payTo"], "value": str(int(tier["amount"])),
        "validAfter": str(now - 60), "validBefore": str(now + 300),
        "nonce": "0x" + secrets.token_hex(32)}
domain = {"name": tier["extra"]["name"], "version": tier["extra"]["version"],
          "chainId": 8453, "verifyingContract": tier["asset"]}
msg = encode_typed_data(full_message={
    "types": {"TransferWithAuthorization": [
        {"name": "from", "type": "address"}, {"name": "to", "type": "address"},
        {"name": "value", "type": "uint256"}, {"name": "validAfter", "type": "uint256"},
        {"name": "validBefore", "type": "uint256"}, {"name": "nonce", "type": "bytes32"}]},
    "primaryType": "TransferWithAuthorization", "domain": domain, "message": auth})
sig = acct.sign_message(msg).signature.hex()
payment = {"x402Version": 2, "resource": challenge.get("resource"), "accepted": tier,
           "payload": {"signature": sig if sig.startswith("0x") else "0x" + sig,
                       "authorization": auth},
           "extensions": challenge.get("extensions") or {}}
req.add_header("PAYMENT-SIGNATURE",
               base64.b64encode(json.dumps(payment).encode()).decode())
resp = urllib.request.urlopen(req)
print("pass:", resp.headers.get("X-Session-Pass"))  # reuse for later calls
print(resp.read(300).decode())
PY

Reuse the pass — no per-call signing:

curl -s https://mcp.whitemagic.dev/mcp \
  -H "X-Session-Pass: wm_pass_..." \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"memory.search","arguments":{"query":"..."}}}'

Common 402 errors: payload is not base64 JSON; signature missing from the authorization; replayed nonce (each authorization is single-use — sign a fresh one); insufficient USDC or wrong chain. Free alternatives: X-WM-Trial: 1 for 10 calls per day, an instant evaluation key (50 recalls/day), or POST /faucet for a 10-minute pass.

What is recorded, and the limits

Gateway audit entries may include a key name or “unknown”, timestamp, method, status, byte count, normalized route, JSON-RPC method and tool name, client family, bounded User-Agent family, latency, and decision details. Tool arguments, query text, response content, bearer tokens, and raw User-Agent strings are not included. An unrecognized non-empty User-Agent is represented by a truncated SHA-256 fingerprint. The anonymous trial limit uses client IP in an in-memory daily counter; the faucet uses IP and an optional payer/address identifier and writes both into certain persistent audit entries. Bundle verification is processed in memory and the submitted bundle is not stored as bundle content. Details in the Privacy Policy and Terms. The evaluation endpoint stores participant-isolated records for its Add/Search/Delete operations; no general expiry schedule is published. Optional persistent API data also includes revocation documents, anchor proofs, payment receipts, caller-claim notarizations (supplied digests and bounded claims, not the underlying prompt or execution), client-encrypted crystal objects, assertion replay nonces, and service signing keys. The optional verification cache is in memory with a 15-minute configured lifetime; assertion nonces are retained until expiry plus clock-skew allowance. Gateway audit logs have a 90-day retention target under periodic rotation; old archives may not expire immediately. Backups of the hosted store and durable authorization state retain up to four weekly remote and twelve weekly local copies; service records removed from active storage may remain in those backups. Audit logs are excluded from that backup set. Other durable state, including owner mappings, service signing keys, receipts, and crystal ciphertext, has no general expiry schedule. Glimind receives operational tool-call spans containing bounded tool name, HTTP status, latency, service labels, and error class, without arguments, results, payloads, tokens, keys, or IP addresses. See the Privacy Policy. The hosted recall lane is read-only and rate-capped; other endpoints follow the access and payment terms above. Services carry no SLA and run under partial kernel confinement – disclosed, not hidden.