"Get it notarized" is shorthand for making a document count. If what your application has to show is that a file existed in a given form by a given date, it helps to be exact about what a notary records, because the timing of content is not on the list.

What a notary attests

A notary watches a named person sign a document, checks that person's identity, and records the event: who appeared, on what date, and what they signed or acknowledged. The notary's seal and journal entry are a record of that appearance.

That is the whole function, and for a deed, an affidavit or a power of attorney it is exactly the right one. The question those documents raise is "did this person really sign this", and a notary answers it.

Two things are not in the record. A notary does not fingerprint the content, so the record says nothing about whether the bytes of a file changed after the signing. And the date is the date of the appearance, not the date the content came into existence. A notarized printout of a photograph establishes that someone presented that printout on that day. It does not establish when the photograph was taken, or that the file on your server today is the same bytes.

The question software usually has to answer

Most timing questions in a product are about content, not signatures. A report was exported on a date and you need to show it has not been edited since. A dataset snapshot fed a model run. A draft was finished before a deadline. A build artifact is the one that was tested. In each case the question is "did this exact content exist by then, and is this the same content now".

A signature date does not attach to bytes. A hash does.

What a hash timestamp attests

Compute the SHA-256 of the file: 64 hex characters, different for any one-byte change, and not reversible into the file. Get that hash written into a public transaction, on a chain whose block times no single party sets. Keep the transaction id with the file.

Later, anyone with the file recomputes the hash, opens the transaction on a block explorer and compares. If they match, a file with this exact hash existed by the block time and has not changed since. That is all it shows. It does not show who made the file, that its contents are accurate, or who owns it. Timing and integrity, not identity.

Side by side

  • Notarization: who signed, and when they signed. The reader trusts the notary's record.
  • Hash timestamp: this exact content existed by this time and is unchanged. The reader trusts a public chain and the arithmetic, and can check both alone.

Neither does the other's job. If a signer's identity and intent are the point, you want a notary. If the content and its date are the point, you want a hash on a public chain. If both matter, anchor the signed document's hash as well.

When to anchor

A hash record speaks only from the anchor time onwards. Nothing can go back and record a date that was never recorded, so the hash has to go on chain at the point the content is final: when the report is exported, the snapshot is taken, the build is cut. In a pipeline that means one call at that step, not a clean-up job months later.

Doing it from code

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, and the call is the same for a one-page PDF or a multi-gigabyte video, because only the hash goes.

import hashlib
import os
import requests

BASE = "https://proofledger.io"
HEADERS = {"Authorization": f"Bearer {os.environ['PROOFLEDGER_API_KEY']}"}

def sha256_file(path):
    h = hashlib.sha256()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(1 << 20), b""):
            h.update(chunk)
    return h.hexdigest()

digest = sha256_file("report-2026-q3.pdf")
# e.g. a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2
r = requests.post(f"{BASE}/api/v1/proof", headers=HEADERS, json={
    "sha256": digest,
    "filename": "report-2026-q3.pdf",
    "external_id": "report-2026-q3",   # your own id; a resend returns the same proof
})
r.raise_for_status()
proof = r.json()   # 201 for a new proof, 200 if this external_id was already recorded
print(proof["id"], proof["polygon_status"], proof["certificate_url"])

polygon_status starts as PENDING and becomes ANCHORED once the transaction lands, usually within a minute. Poll GET /api/v1/proof/{id}, or register a webhook with POST /api/v1/webhooks and handle the proof.polygon.anchored event; its body carries the proof and its bundle, and the ProofLedger-Signature header lets you check it came from us.

Then store the bundle next to the file:

curl -H "Authorization: Bearer $PROOFLEDGER_API_KEY" "https://proofledger.io/api/v1/proof/42/bundle?download=1" -o report-2026-q3.pdf.proof.json

The bundle holds the hash, the chain, the transaction id and the anchor time. With it and the file, the check no longer needs ProofLedger.

Where the notary still belongs

None of this argues against notarization. When a signer's identity is what a reader will ask about, a notary is the instrument. The mistake is using one to answer a timing question: a seal on a document dated Tuesday says someone signed on Tuesday, and nothing about what the content looked like on Monday. Whether a court accepts a notarized page, a hash timestamp, or either one is for the court and the lawyers; what the two records differ on is what they describe and who can check them.

To check a ProofLedger proof without ProofLedger, install the open-source verify-proof tool, run verify-proof verify report-2026-q3.pdf --proof report-2026-q3.pdf.proof.json offline, and open the bundle's transaction id on any Polygon block explorer. The API is documented at https://proofledger.io/api.html.