How to Prove You Wrote Something (Before Someone Else Claims You Didn't)

Two years ago, the biggest authorship risk a freelance writer faced was plagiarism — someone else copying their work. Today, the more common dispute runs the other direction: a client accuses a human writer's genuine, original work of being AI-generated, withholds payment, or demands a rewrite "with more human voice" on text that was never touched by AI in the first place.

This isn't a hypothetical. Detection tools that claim to identify AI-written text are notoriously unreliable — studies and independent testing have repeatedly shown they produce both false positives (flagging genuine human writing as AI) and false negatives (missing AI-generated text entirely), yet clients increasingly run submitted work through these tools anyway and treat the output as gospel. A freelancer with no way to counter a bad detector result is stuck arguing a negative, which is close to impossible to do convincingly with words alone.

At the same time, the older problem hasn't gone away either: clients or collaborators who quietly repurpose a freelancer's draft, publish it under someone else's byline, or "forget" the original terms of an agreement once the deliverable exists. In both cases — the AI accusation and the ownership dispute — what's actually missing is the same thing: independently verifiable proof of exactly when a specific piece of text existed, in a form nobody can quietly alter after the fact.

What a timestamp can prove — and what it can't

Before going further, it's worth being precise about what cryptographic timestamping actually establishes, because overselling it undermines its credibility.

A cryptographic timestamp, properly implemented, can prove: this exact sequence of characters existed at this exact moment. That's it. It doesn't prove who typed it, whether it was written with the help of an AI tool, or whether it was later edited into a "final" version. What it does prove is that the specific text you're holding a certificate for is byte-for-byte identical to something that existed at a specific, independently verifiable point in time — which is a narrower but far more useful claim than "an AI detector says this is 73% human."

The mechanism that makes this possible is a combination of two well-established technologies: cryptographic hashing and blockchain timestamping.

The technical foundation: SHA-256 hashing

SHA-256 is a cryptographic hash function — a mathematical process that takes any input (in this case, your text) and produces a fixed-length string of characters, called a hash or fingerprint, that's unique to that exact input. Change a single character anywhere in the original text — a comma, a typo fix, a single word — and the resulting hash changes completely and unpredictably. There's no way to work backward from a hash to reconstruct the original text, and there's no realistic way for two different pieces of text to produce the same hash by coincidence.

This is the same technology that underpins password storage, digital signatures, and file-integrity verification across the software industry — it isn't a novel or experimental technique, it's decades-old, extensively studied cryptography.

What this means practically: if you generate a SHA-256 fingerprint of your draft the moment you finish it, that fingerprint becomes a mathematically verifiable "fingerprint" of that exact text. Anyone who later has both the fingerprint and the original text can confirm they match — and just as importantly, if someone tries to claim a modified version is what you "originally" wrote, the fingerprints won't match, immediately exposing the discrepancy.

Why the fingerprint alone isn't enough — and what blockchain timestamping adds

A hash proves what the text is, but on its own it doesn't prove when it existed — you could generate a hash of a document today and simply claim you made it a year ago. This is where a second layer, independent timestamping, becomes necessary.

OpenTimestamps is an open protocol that anchors a hash to the Bitcoin blockchain — a public, distributed ledger that a huge number of independent computers around the world continuously verify and extend. Once a hash is submitted and included in a confirmed Bitcoin block, its existence at that point in time becomes part of a record that would require rewriting the entire subsequent history of the Bitcoin network to falsify — something that is, for all practical purposes, not achievable by any single party, including the timestamping service itself.

This is the meaningful difference between a blockchain-anchored timestamp and a timestamp claimed by a single company's internal database: a company's database is only as trustworthy as the company itself, and can theoretically be altered by that company (or compromised by an attacker) after the fact. A Bitcoin-anchored timestamp doesn't depend on trusting any single party — the proof is verifiable independently by anyone, using open-source tools, indefinitely into the future, even if the original service that created it disappears entirely.

How a full authorship certificate is built, step by step

Combining these two pieces — hashing and blockchain anchoring — into something usable for a freelancer or writer looks like this:

1. You finish a draft. This can be an article, an essay, a piece of client work, a contract clause you drafted, or any other original text.
2. The text is hashed locally, in your browser. A SHA-256 fingerprint is generated from the exact text, combined with your name and a timestamp, without the text itself ever being uploaded anywhere.
3. The fingerprint — not the text — is submitted to the OpenTimestamps calendar servers. Only the hash leaves your device; the actual content of your writing never does.
4. The calendar servers batch and submit the hash to the Bitcoin network. Confirmation typically completes within a few hours, once the transaction is included in a mined block.
5. You receive a `.ots` proof file. This small file is your evidence — it contains everything needed to independently verify, at any point in the future, that your specific hash was anchored to a specific, confirmed point in Bitcoin's timeline.
6. Anyone can later verify the proof by re-hashing the original text and confirming it matches the `.ots` file's record, using free, open tools at opentimestamps.org — no account, no fee, no dependency on the original issuing party.

Real situations where this matters

The AI-accusation dispute

A client runs your submitted article through a free online AI detector, gets a "68% likely AI-generated" result (these tools are known to misfire on genuinely human writing, especially formal or technical prose), and withholds payment or demands a rewrite. A timestamp certificate doesn't disprove the detector's claim directly — but it does prove that the exact text in question existed, unmodified, at the moment you submitted it, which is often enough to shift the conversation from "prove you're human" (nearly impossible) to "here's independently verifiable proof of when I delivered this exact draft" (a much stronger position, especially combined with your own drafting history, revision notes, or process documentation).

The disappearing draft

You share a proposal, pitch, or sample chapter with a potential client or collaborator, and months later a suspiciously similar piece of work appears elsewhere — under someone else's name, or as part of a project you were never credited on or paid for. A certificate generated the moment you finished your draft establishes, independently of your word against theirs, that your version existed first.

The "which version is final" dispute

A client disputes that a certain draft was the one they approved, perhaps after a scope disagreement, and claims a different, less-developed version was what you delivered. Because a hash changes with even a single-character edit, a certificate tied to the exact approved text can immediately settle which version is being discussed — no ambiguity, no relying on email timestamps that can be forwarded, edited-and-resent, or simply lost.

Ghostwriting and contractor agreements

Ghostwriters and contract writers frequently produce work that's published under someone else's name by design — which is exactly the situation where private, verifiable proof of authorship matters most, since public credit isn't an option. A certificate lets a ghostwriter maintain a private, timestamped record of their own contribution without needing public attribution to prove it exists.

What actually goes into the certificate

A complete authorship certificate combines several pieces of evidence into one document:

• The SHA-256 fingerprint of the exact submitted text, mathematically unique to that content.
• The author's name, as declared at the time of certification.
• An issued timestamp, marking when the certificate was generated.
• An approximate writing-pattern signal — sentence-length variation (burstiness) and word-repetition ratio — offered honestly as a rough indicator, not a verdict.
• A QR code linking to a verification reference for the certificate.
• (Pro tier) A Bitcoin-anchored `.ots` proof file, independently verifiable at opentimestamps.org indefinitely, plus custom branding instead of a third-party logo.

Why everything runs in the browser, not on a server

A meaningful design decision behind a tool like this is that the actual text being certified is never uploaded anywhere — the SHA-256 hashing happens locally, in your browser, using the Web Crypto API built into every modern browser. Only the resulting fingerprint (not the content) is ever submitted to the OpenTimestamps calendar servers for blockchain anchoring.

This matters for a straightforward reason: the whole point of an authorship certificate is confidentiality-compatible proof. A freelancer under an NDA, or simply protective of unpublished work, shouldn't have to choose between protecting their authorship and protecting their content. Because the hash is mathematically one-directional — you cannot reconstruct the original text from the fingerprint — the certificate can be shared freely (even published publicly) without ever revealing the underlying draft.

Building the habit: when to certify, not just whether to

The technology only helps if it's used at the right moment, and the right moment is almost always before a dispute exists, not after one starts. A few practical habits:

• Certify at the moment of submission, not before revisions. The certificate should match the exact text a client actually receives, so that it's directly useful as evidence about that specific delivery.
• Certify pitches and proposals, not just finished work. Ownership disputes over ideas and pitches are just as common as disputes over finished drafts, and often harder to resolve because there's no "final deliverable" to point to.
• Keep certificates organized by project, alongside your other project records, so you can locate the relevant one quickly if a dispute arises months later.
• Don't wait for a dispute to start certifying. A certificate generated after a disagreement has already begun is far less persuasive than a habitual practice applied to every piece of client work.

Solo vs. Pro: choosing a plan

Solo covers the core use case well: a mathematically verifiable fingerprint and timestamp, generated the moment you need it, for unlimited documents. Pro adds the independently verifiable Bitcoin anchoring — the version of the proof that doesn't depend on trusting the issuing service at all — plus the option to present certificates under your own name or agency branding rather than a third-party logo, which matters if you're presenting certificates directly to clients as part of your professional process.

What a certificate is — and isn't — good for

Frequently asked questions