OPERATIONAL anchoring on mainnet · 0 anchors this hour (0/1000 all services) no issues in 18h 43m report a problem

📄 Filestamp Notary — proof of existence

Timestamp any file on-chain without revealing it — a track, a video master, a photo, a contract, a dataset. Hash it locally (in your browser, or yourself) and send only the 64-char fingerprint; later, re-hash to prove the document existed at or before the block's timestamp.

Any file — audio, video, image, document, archive. It never leaves your browser.

— or paste text to timestamp (no JavaScript needed) —

privacyonly the sha256 is sent — the file never leaves your machine
on-chainOP_RETURN bsv.cx not1 <sha256>

Endpoints

POST /n{ "hash": "<sha256hex>" } or { "content": "text" }
GET /n/:hashJSON proof
GET /n/:hash/viewhuman proof page
printf '%s' "my document" | sha256sum
curl -X POST https://bsv.cx/n -H 'content-type: application/json' -d '{"hash":"<that hash>"}'

Verify it yourself

What this proves — and the one catch for media

provesThese exact bytes existed at or before the block's timestamp. Any file type — SHA-256 does not care whether it is a contract or a master recording.
the catchRe-encoding changes the hash. A PDF usually travels byte-identical, but audio and video rarely do — most platforms transcode on upload. So this proves your master existed on a date; it will not match a re-encoded copy someone else is holding. Keep the exact file you hashed.
not provedWho made it, who owns it, or that anything claimed about it is true. If you want authorship on the record, sign a statement — we timestamp the claim, we never vouch for it.

Re-hash your file with SHA-256 and confirm it matches. The anchor's OP_RETURN carries bsv.cx / not1 / <hash>, and the block timestamp bounds when it existed.

And you don't have to trust an explorer for this, either. bsv.cx runs its own block-headers service, syncing the chain's headers directly over the BSV peer-to-peer network. For every anchor it recomputes the transaction's block Merkle root from an SPV proof and confirms it against those headers before publishing the proof on the record. Look for the green "✓ Independently verified against bsv.cx's own block headers" line on any proof page, open it, and recheck the same proof against any header source you trust — no explorer, and no bsv.cx, in the trust path.

🧾 Batch — thousands for one anchor

Timestamp thousands of fingerprints for the price of one transaction: they're committed to a single Merkle root (RFC 6962 — domain-separated, single SHA-256, promote-odd), and only the root is anchored. Every item still gets an inclusion proof you can verify independently.

on-chainOP_RETURN bsv.cx not2 <merkleRoot>
limitup to 3000 hashes per batch (413 above)
POST /n/batch💳 paid { "hashes": ["<sha256hex>", …] } or { "contents": ["…"] }
GET /n/:hash/proofinclusion proof (leaf + audit path) — free
GET /n/b/:rootbatch summary — free

Free vs paid

Notarizing one file at a time (POST /n above) is free. Bulk batching is paid, because every batch spends a real on-chain anchor — see pay-per-call. Verification is free and always will be: proofs, batch summaries and records need no payment, because a proof nobody can check is not a proof.

priceone payment buys one batch; the invoice is sized by how many hashes you send — 300 hashes per 300-sat unit
at full size300 hashes ≈ 1 satoshi per timestamped file — one anchor amortised across the batch
re-submittingan identical batch performs no new anchor, so it is served free — you are not charged again

Unpaid requests get an HTTP 402 with an invoice sized for that batch. The pay-per-call docs walk through the loop, and the two curls below are a complete working client.

# 1. quote (no payment) -> 402 with an invoice sized for these hashes
curl -X POST https://bsv.cx/n/batch -H 'content-type: application/json' -d '{"hashes":["<sha256hex>"]}'

# 2. pay it, then re-request with the payment attached (x402, one round trip)
curl -X POST https://bsv.cx/n/batch -H "payment-signature: <x402 payment>"   -H 'content-type: application/json' -d '{"hashes":["<sha256hex>","…"]}'

Fold a proof's audit path into a root and confirm the anchor's OP_RETURN carries bsv.cx / not2 / <root>. That is the whole check — the audit path, the root and the OP_RETURN are all on the public chain, so you verify it against Bitcoin itself, not our database.

← back to bsv.cx