OPERATIONAL anchoring on mainnet · 1 anchors this hour (4/1000 all services) last issue 20h 28m ago report a problem

📄 Filestamp Notary — proof of existence

In plain terms: want proof a file existed on a certain date — without showing anyone the file itself? We take a "fingerprint" of it (not the file) and timestamp that on the blockchain. You keep the file privately; the blockchain keeps permanent proof it existed. 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.

📡 No internet on the sending device? Use radio

Both plain timestamping (not1) and signed attestations (att1 — sign a statement with your own wallet, we only ever relay the signature) are reached over Reticulum instead of HTTPS, so a device with zero internet connectivity — just a LoRa radio — can still get something anchored on BSV and get the proof back. Same anchors, same records, different transport. See reaching bsv.cx without internet → for how it works and what's proven so far.

New to this? A few quick definitions
on-chain / anchoredwritten permanently into the Bitcoin SV blockchain, where anyone — not just bsv.cx — can check it.
hash / SHA-256a short "fingerprint" generated from data. The same input always produces the same fingerprint, but you can't work backwards from the fingerprint to recover the original data — so sharing a hash never leaks what it came from.
OP_RETURNa small public "note" field built into every Bitcoin transaction. bsv.cx writes fingerprints there — that note is what actually gets checked when you verify a proof.
Merkle rootone fingerprint that stands in for a whole batch of items at once, so thousands of files can be proven with a single blockchain entry instead of thousands of them.
x402 / payment-signaturebsv.cx's pay-per-call system — a tiny BSV payment attached directly to an API request instead of a subscription or an account. See pay-per-call.

← back to bsv.cx