Notarize from your code, your pipeline, or your agent.

The model in one paragraph

You hash a file locally to 0x + 64 hex. You get a price (/quote), open a paid order and receive a one-time payment address (/order), pay it in USDC/USDT, poll until it confirms (/status), then anchor the hash (/notarize). You get back a self-contained proof certificate that anyone can check (/verify) without notaros. No stored value; each order is a single, paid-in-full notarization.

REST API

POST /quote

Price a notarization for a chain + token.

POST https://api.notaros.com/quote
Content-Type: application/json

{ "chain": "base", "token": "USDC" }

→ 200
{ "baseCostAtomic": "...", "callerFeeAtomic": "...",
  "gasFrontAtomic": "...", "priceAtomic": "...",
  "chain": "base", "token": "USDC" }

POST /order

Open a paid order. The returned address is the payment reference — pay the exact priceAtomic to it in the quoted token. No memo needed.

POST https://api.notaros.com/order
{ "chain": "base", "token": "USDC" }

→ 200
{ "orderId": "order_...", "address": "0x...",
  "priceAtomic": "...", "chain": "base", "token": "USDC" }

GET /status/{orderId}

Reorg-stable payment status. Poll until status is confirmed.

GET https://api.notaros.com/status/order_...

→ 200
{ "orderId": "order_...", "status": "waiting | detected | confirmed",
  "priceAtomic": "...", "paidAtomic": "...", "confirmations": 0 }

POST /notarize

Anchor a paid hash. Requires the order to be paid. Returns ok:true, code:"anchored" with a certificate, or a machine code on failure (payment_not_confirmed, already_anchored, invalid_hash, unknown_order, sc_call_failed, service_halted).

POST https://api.notaros.com/notarize
{ "orderId": "order_...",
  "hash": "0x<64 hex>",
  "algorithm": "sha-256",
  "wantBitcoin": true }

→ 200
{ "ok": true, "code": "anchored",
  "certificate": {
    "hash": "0x...", "algorithm": "sha-256",
    "chainId": 8453, "contract": "0x...",
    "txHash": "0x...", "blockNumber": 0, "logIndex": 0,
    "timestamp": 0, "ots": { "otsBase64": "...", "status": "pending", "calendars": ["..."] }
  } }

POST /verify

Vendor-independent verification of a certificate. Reads notarizedAt(hash) on the certificate’s chain/contract and checks the on-chain timestamp matches (and the OTS proof if present). Never uploads a file — pass the certificate, and optionally a locally computed hashHex to cross-check.

POST https://api.notaros.com/verify
{ "certificate": { ... }, "hashHex": "0x<optional>" }

→ 200
{ "valid": true, "file": {...}, "baseAnchor": {...}, "bitcoin": {...}, "reasons": ["..."] }

Hashing (client-side, always)

Compute the fingerprint yourself; never send the file. Examples:

# shell
printf '0x'; shasum -a 256 yourfile | cut -d' ' -f1

// browser (WebCrypto)
const buf = await file.arrayBuffer();
const h = await crypto.subtle.digest('SHA-256', buf);
const hex = '0x' + [...new Uint8Array(h)].map(b=>b.toString(16).padStart(2,'0')).join('');

MCP — Model Context Protocol

notaros runs an MCP server so an AI agent can notarize and verify natively, as tools. The tool surface mirrors REST: price, order, notarize, and status for the notarize flow, plus notaros_verify for the vendor-independent read. The agent hashes the file locally, pays the returned order address, and receives the machine-readable, Ed25519-signed receipt as the deliverable (the PDF stays a web artifact). Connection details and the tool manifest are provided with developer access.

A2A — agent-to-agent

For agent-to-agent delegation, notaros exposes an A2A endpoint covering the same capability set (quote, order, notarize, status, verify) so one agent can commission a notarization from another. Same client-side hashing, same pay-per-unit model, same independently verifiable certificate.

Client libraries

A thin JavaScript client wraps the REST flow (hashFile, quote, createOrder, notarize, status, verify, and a high-level notarizeFile that hashes → orders → waits → anchors). CLI, Python, and Go clients share the identical public surface. Override the base URL with NOTAROS_API or a constructor option.

Pricing for developers

Every price is published and self-service — no account, no negotiation. A single programmatic anchor over REST, MCP, A2A, or x402 is $3.00 and returns a signed JSON receipt plus an OpenTimestamps .ots proof (the full-service web package, at $25, is the one that adds the signed PDF certificate and hosted verifier).

To notarize many documents at once, anchor their fingerprints as a single Merkle root in one /notarize call. The per-document price drops automatically as the batch grows; /quote returns the exact price for your quantity — no account and no quote from a person.

See the full pricing page for all three channels side by side.