Do I need an account to verify?

No. Verification is free and requires no account. Your file is hashed in your browser and the blockchain anchor is read directly from a public RPC; notaros is never contacted.

Is my file uploaded when I verify?

No. The file is hashed locally with SHA-256 and never leaves the page. Only its fingerprint is compared against the on-chain record.

Can I verify a proof that was not made by notaros?

Yes. The verifier also checks bare OpenTimestamps (.ots) proofs for files notaros never touched, because it uses open standards.

Can I still verify if notaros shuts down?

Yes, forever. A proof rests on three open standards, none of which is notaros: SHA-256 (NIST FIPS 180-4) to recompute the fingerprint, the RFC 6962 Merkle construction the self-describing proof names, and a Bitcoin commitment via OpenTimestamps. Verify with standard public tools — sha256sum or openssl, the OpenTimestamps client, and any Bitcoin block explorer such as mempool.space. Base is only a convenience anchor; Bitcoin/OpenTimestamps is the permanent one. notaros never has to be online.

Free · no account

Verify a proof — independently.

This is the whole promise of notaros made checkable. Your file is hashed in your browser and never leaves this page; the on-chain anchor is read straight from a public Base RPC. We are not contacted at any point.

zero upload reads the chain directly works offline of us

1 · Your proof The file you notarized (optional — hashed locally to prove it matches the certificate) The proof certificate (JSON) Base RPC to read from (optional — defaults to a public one; paste your own if you prefer)

2 · Verify it yourself, by hand

You never have to trust this page. Reproduce every step with your own tools:

Hash your file. On any machine:
```
sha256sum yourfile        # or: shasum -a 256 yourfile
```
The result (prefixed with 0x) must equal the certificate’s hash.
Read the Base anchor. Call notarizedAt(hash) on the contract with any RPC:
```
cast call <contract> "notarizedAt(bytes32)(uint256)" <hash> --rpc-url https://mainnet.base.org
```
A non-zero result is the proof-of-existence timestamp (unix seconds) — and it must equal the certificate’s timestamp. Or open the txHash in a Base block explorer and read the Notarized event. Pin the issuer: the certificate’s chainId/contract are self-declared — confirm the contract is the real notaros deployment before you trust a check mark.
(If present) verify the Bitcoin proof. Save the certificate’s ots.otsBase64 (base64-decoded) as proof.ots next to your file, then:
```
pip install opentimestamps-client
ots verify proof.ots        # checks the file's sha256 was committed to a Bitcoin block
```
A pending proof is still upgrading — run ots upgrade proof.ots later.

The certificate is self-contained: {hash, algorithm, chainId, contract, txHash, blockNumber, logIndex, timestamp} (+ optional ots). Anyone, anywhere, forever, without us.

3 · Verify entirely on your own — with tools that aren’t ours

notaros could disappear tomorrow and your proof would still stand. Here is how to confirm it using nothing of ours — because a notaros proof rests on three open standards, none of which is notaros:

Compute the fingerprint yourself — SHA-256. Any operating system already ships a tool:
```
sha256sum yourfile                 # coreutils (Linux)
openssl dgst -sha256 yourfile      # anywhere OpenSSL is installed
certutil -hashfile yourfile SHA256 # Windows
```
The result must equal the certificate’s hash. SHA-256 is the algorithm defined by NIST FIPS 180-4 ↗ — it is in every OS and security tool, and always will be.
Reproduce the Merkle construction — RFC 6962. When a proof is part of a Merkle batch, the proof file names the exact construction it uses — the Certificate Transparency Merkle tree of IETF RFC 6962 ↗, the same construction that underpins web-PKI Certificate Transparency. Because the proof is self-describing, anyone can recompute the root with any of the many independent open-source verifiers.
Confirm permanence on Bitcoin — OpenTimestamps. This is the durable guarantee. Verify the certificate’s .ots file against the Bitcoin blockchain with the open client from opentimestamps.org ↗ (source and install: opentimestamps-client on GitHub ↗):
```
ots verify proof.ots
```
Then inspect the anchoring Bitcoin block yourself on mempool.space ↗ or blockstream.info ↗. A self-contained .ots proof plus Bitcoin verifies existence forever, trusting no company.
(Convenience) Read the Base anchor. The Base anchor is only the fast, cheap convenience anchor — Bitcoin/OpenTimestamps is the permanent one. Open the certificate’s txHash in the public explorer basescan.org ↗ and read the Notarized event for the on-chain timestamp.

Our own downloadable offline verifier is one option among these — not a requirement. Every tool above is external, authoritative, and outside our control. That is the point: your proof depends on open standards, never on notaros.

Verification is free and always will be. A proof only you can check is worthless — so anyone can check yours. See how the proof is built →