A timestamp proof is only as good as the check behind it. Anyone can say a file existed on a date. The question for a developer adding proof of existence to an app is who, exactly, a third party has to trust to confirm that claim later. Verification models split on one point: does checking the proof mean trusting an intermediary, or can the reader recompute it from public data? Only the second kind survives the vendor going away.
Model 1: the vendor's portal
Most timestamping and notarization services verify through the same place they sell: a hosted page. Someone uploads the file, or pastes a reference number, and the platform answers yes or no. The check runs on the vendor's servers, against the vendor's database, and the answer is a page render rather than a computation you can inspect.
What you are trusting: the vendor's continued existence, the integrity of its database, and its willingness to keep answering the same way. If the company is sold, shut down or simply offline on the day it matters, the verification path goes with it.
Model 2: a signed certificate
A second model hands you a signed document, often a PDF, that asserts a timestamp exists. It carries a signature block, maybe a QR code and a reference number. Confirming it usually means calling the issuer's system, or accepting that the signature is genuine without an independent way to re-derive what it signs.
What you are trusting: the issuer's signing key and the issuer's word. This is closer to a notarized document than to a cryptographic proof. An honest issuer makes it work; it is still an assertion backed by an institution, not a derivation the reader can run.
Model 3: a public ledger plus local recomputation
The third model puts the record somewhere the vendor does not control and gives you everything needed to check it yourself:
- The file's SHA-256 hash is written into a transaction on a public blockchain.
- You hold a proof bundle: the hash, the chain, the transaction id and the anchor time.
- Verifying is two steps anyone can run. Recompute the hash from the bytes and compare it with the bundle. Then look the transaction up on a public block explorer and confirm it carries that hash.
What you are trusting: the hash function and the public chain. Neither belongs to the vendor. If the company disappears, the transaction is still on the chain and the bundle is still on your disk.
What ProofLedger does
ProofLedger is proof of existence as an API: send a file's SHA-256 hash, get a Polygon-anchored certificate anyone can verify without us. The file never leaves your machine; only the 64-character digest is sent, with an optional file name. Each proof is anchored on Polygon in its own public transaction, usually within a minute.
The record of a proof is that Polygon transaction plus the proof bundle. ProofLedger's certificate page, database and public verify endpoint are convenience views of the record, not the record itself. That is the design choice that puts it in model 3: nothing in the verification path needs ProofLedger to be online.
Verifying a proof yourself
This is the part worth running rather than reading about. Install the open-source tool (Python, no dependencies; a Node port is on npm under the same name):
pip install verify-proof
Hash the file:
verify-proof hash contract.pdf
# SHA256: a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2
# File: contract.pdf
Check it against the bundle you saved when the proof was created:
verify-proof verify contract.pdf --proof contract.pdf.proof.json
# VERIFIED: File matches the proof bundle. The bundle says it was anchored on polygon at 2026-10-15T02:11:09.512Z in transaction 0xabc123.... Look that transaction up on a block explorer to confirm it: https://polygonscan.com/tx/0xabc123...
The same check from Python:
from verify_proof import hash_file, load_proof, verify_proof
file_hash = hash_file("contract.pdf")
bundle = load_proof("contract.pdf.proof.json")
result = verify_proof(file_hash, bundle)
print(result["verified"]) # True when the hash matches and the bundle names a transaction
print(result["tx_id"]) # the Polygon transaction to look up
print(result["anchored_at"]) # the anchor time, as the bundle states it
print(result.get("explorer_url")) # Polygonscan link for that transaction
Be precise about what this confirms. verify-proof hashes the file and compares it with the bundle. It does not read the chain. A VERIFIED result means the file matches the bundle and the bundle names a transaction; the anchor itself is confirmed by the second step, opening that transaction on a block explorer and checking that it carries the hash. The block's timestamp is the anchor time. Two checks, one local and one against the public chain, and neither asks ProofLedger anything.
The public lookup, and why it is optional
ProofLedger also answers a hash lookup with no API key:
curl "https://proofledger.io/api/v1/verify?hash=a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2"
{
"found": true,
"proof": {
"id": 42,
"sha256": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2",
"polygon_status": "ANCHORED",
"chain_tx": "0xabc123..."
},
"certificate_url": "https://proofledger.io/cert/42",
"explorer_url": "https://polygonscan.com/tx/0xabc123..."
}
It is limited to 120 requests an hour per IP and returns found: false with the hash echoed back when there is no proof. Use it as a quick first check, or to find the transaction id for a hash. Do not build your verification on it: the point of model 3 is that the bundle and the chain are enough.
What a proof shows
A proof shows that a file with this exact hash existed by the anchor time and has not changed since. It does not show who made the file, that its contents are true, or who owns it. Whether a court accepts any of this is for the court and the lawyers; the technical claim is the one above, and it is the one you can check.
Which model to pick
If verification runs through a login screen, the receiving party is accepting a dependency on the vendor's uptime, database and good faith for as long as the proof matters. If it runs through a certificate taken on faith, they are trusting a signature they cannot re-derive. If it runs through a public chain and a bundle they hold, they are trusting mathematics and public data, and they can repeat the check whenever they like.
To check a proof without ProofLedger: run verify-proof verify against the bundle, then open the transaction on any Polygon block explorer and confirm it carries the hash. The API and the bundle endpoint are documented at https://proofledger.io/api.html.