Cryptographic Prior Art: The Startup Shield Against Patent Trolls
Cryptographic prior art for software patents is one of those phrases that sounds like it belongs in a law firm’s memo — until the day a demand letter arrives claiming you’re infringing a patent on something you built two years earlier. Then it becomes the most practical question in your engineering organization: can you prove your code existed on a specific date?
Not “our Jira tickets show it.” Not “the lead dev remembers.” Proving it in a way that survives a hostile audit.
This article explains what cryptographic prior art actually is, why it matters more to startups than to incumbents, and how a GitHub App can give you that proof without anyone on your team learning a new tool. Timestamp GIT is the managed service we’ll use as the reference implementation throughout — install once, automatic nightly anchoring into Bitcoin, nothing to run.
What Is Cryptographic Prior Art and Why Should You Care?
Prior art is evidence that an invention already existed before someone else claims to have invented it. In patent law, prior art is what invalidates a claim. In software, prior art is usually the thing nobody bothered to record properly — because recording it seemed like overhead until it mattered.
Cryptographic prior art is proof of existence secured by cryptography and a public blockchain rather than by trust in an internal system. Concretely: your code is reduced to a one-way hash, that hash is anchored into Bitcoin, and the anchor proves the hash existed at a known block height. Anyone can verify it. Nobody can retroactively alter it.
Why does a startup need this?
- Patent trolls. Non-practicing entities file broad patents on common techniques and then look for companies with revenue and no legal budget. If you implemented the technique first but can’t prove it, you settle.
- Employee disputes. When a senior developer leaves, ownership of “the feature they conceived” becomes a negotiation. An immutable date turns it into a fact.
- The clean-room defense. A competitor claims independent development. Proof that your finished logic predates their launch by 18 months is a wall they can’t climb.
- Fragile logs. Git history lives on servers you rent, in databases with admin access. In a legal review, internally generated logs are routinely characterized as self-serving.
That last point is the gap. Traditional IP protection is either expensive (patents) or weak (internal logs). Cryptographic anchoring sits in between: cheap, fast, and mathematically verifiable.
Timestamp GIT closes that gap with a single GitHub App installation. It reads commit hashes, batches them, and anchors the batch into Bitcoin each night. Your developers never change their workflow.
The Real-World Analogy: A Notary Public for Your Code
Think about how a notary works. You walk in with a document. The notary checks your identity, stamps the document with a date and seal, and records it. Later, if someone questions when that document existed, the notarial record settles it — not because the notary is trustworthy in the abstract, but because the act itself is hard to backdate.
Cryptographic prior art is a notary for your repository, with two upgrades:
- The notary never reads the document. The notary only sees a fingerprint — a hash. That’s the zero-knowledge property.
- The seal is mathematical, not institutional. A human notary’s authority rests on a license and a filing system. A Bitcoin anchor rests on proof-of-work and a public ledger that thousands of independent parties have validated.
Timestamp GIT plays the notary role: it collects your commit hashes, batches them daily, and publishes the resulting proof back into a dedicated branch of your repo. But if Timestamp GIT disappeared tomorrow, the proof would still verify against Bitcoin. The notary’s seal outlives the notary.
That distinction matters for compliance reviewers. You aren’t being asked to trust a vendor’s database; you’re being handed a receipt that anyone can check.
How It Works Under the Hood: From Commit to Bitcoin
Three steps, in order. None of them require you to learn OpenTimestamps or touch a Bitcoin transaction.
Step 1 — The fingerprint
Every Git commit already has a unique hash — SHA-1 or SHA-256 depending on your repository configuration. That hash represents the exact state of your entire repository at that moment.
git log -1 --format="%H %ci"
# 9f2c1a7e4b8d3c5f6a0e2d1b7c4a9f8e3d6b2c1a 2026-11-04 09:41:22 +0100
That 40-character string is the fingerprint. It’s one-way: you can’t reconstruct the code from it, which is exactly why it’s safe to hand to a third party.
Step 2 — The anchor
Timestamp GIT extracts only commit hashes. Each night, a worker groups all pending hashes, creates a manifest text file per repository, builds a Merkle tree natively, and anchors the Merkle root into Bitcoin using the OpenTimestamps protocol via public OTS calendars.
The Merkle tree is the important part for scale. Instead of one transaction per commit, thousands of commits collapse into a single root hash. Any individual commit can later be proven to belong to that root through a short chain of hashes — the same structure Git itself uses.
Step 3 — The proof
You receive a .ots receipt file plus the manifest. Both are pushed back into your repository in a dedicated timestamps branch or a separate shadow repository. Bitcoin block confirmation takes a few hours — typically around three — so the proof writing happens a few hours after the nightly batch.
After that, you can prove to a lawyer, an auditor, or a court that the code existed on that date, and verify it independently.
Two deployment modes, both zero-knowledge
- Standard mode (GitHub App). The app reads only the HEAD commit hash of monitored repositories. It needs read-only access to the source repo (GitHub offers no hash-only permission) and read-write to the target repo where proofs land.
- Enterprise ZK mode. A short GitHub Action runs on your infrastructure and pushes only the commit hash to the API. No read access to the source repository is required — only read-write on the target repo.
In both cases, source code never leaves your environment. For the deeper architectural picture, see the implementation page.
Why It Matters: Debunking Common Misconceptions
“Git commit timestamps are enough.”
Git commit dates are fields in a file in a repository you control. They can be rewritten — trivially by a rebase, and thoroughly by anyone with database access to your hosting provider’s backend. What blockchain anchoring adds is immutability: the date is fixed by a block that thousands of independent nodes accept.
“I need to patent my code.”
You may want patents for some inventions. But for the vast majority of software IP, the practical goal is proving you had it first, not excluding others from using it. Prior art does that job, and it costs a tiny fraction of a patent filing. If you’re specifically weighing the two, our patent vs timestamp breakdown goes deeper. The short version: patents take years and cost five figures; a timestamp takes a night.
“Blockchain timestamps are complicated.”
Doing this the hard way means generating hashes yourself, manually submitting them to a calendar server, and managing your own transactions. That’s the raw OpenTimestamps path, and it’s not something you want to hand to a rotating team of engineers.
Timestamp GIT removes that layer entirely. There is no CLI. There are no manual steps. You install the GitHub App once.
“It’s expensive.”
The free tier covers public repositories. Pro Agency is $49/month for private repositories. Enterprise ZK, which runs the hash-push through a GitHub Action on your own infrastructure, is $199/month. Compare that to a single hour of patent counsel.
“A timestamp proves I wrote it, right?”
Not on its own. A hash proves the code existed at a given moment. Authorship is a separate question, usually established by repository history, contributor records, and context. What the timestamp nails down definitively is the existence date — which is precisely the fact that patent disputes and clean-room defenses turn on.
How Timestamp GIT Automates Cryptographic Prior Art
The workflow is deliberately short.
- Install the GitHub App at timestampgit.dev and select the repositories to monitor. No developer machines are touched, nothing to install locally.
- Commit as usual. On every push, the app detects new commits via webhooks and queues the hashes in an in-memory key-value store.
- Wait for the nightly cron. At midnight, pending hashes are grouped, manifests are built, Merkle roots are anchored into Bitcoin.
- Collect the proof. Manifests and
.otsfiles appear in your timestamps branch or shadow repository a few hours later.
From there, verification is available through several surfaces:
- Public status dashboards (
/status/{user}/{repo}) showing proof longevity, earliest anchor date, daily regularity, Bitcoin block and transaction data, a calendar heatmap, and downloadable audit CSV and PDF certificate. - Browser-based verification at
/verification/{user}/{repo}/{date}— the full Merkle chain recomputes locally in the browser, so nobody sees what you’re checking. - Embeddable badges for your README, with markdown snippets generated at connection time.
Private repositories append an encrypted HMAC to their status URLs, instance-specific, so only authorized users can read them.
API access for compliance tooling
If you need to feed proof status into an audit system, the public endpoints are straightforward:
# Last anchored Bitcoin block for a repository
curl -s https://timestampgit.dev/api/statusLast/acme/payments-service
# Full Merkle chain data for local verification of a specific day
curl -s https://timestampgit.dev/api/verify/acme/payments-service/2026-11-04
# Complete audit ledger as CSV
curl -s -o audit.csv https://timestampgit.dev/api/audit/acme/payments-service
That CSV export is often the single most useful artifact in a due-diligence conversation — it turns “we have timestamps” into a dated, verifiable ledger.
Docker self-hosting for air-gapped environments
Some organizations cannot send even a hash to a third party, or operate in environments with no outbound internet from source systems. Timestamp GIT ships as a Docker image for those cases.
A quick-start Docker Compose setup looks like this:
services:
timestampgit:
image: rue1401/timestampgit:prod
ports:
- "8080:8080"
volumes:
- ./data:/app/data
restart: unless-stopped
valkey:
image: valkey/valkey:8
restart: unless-stopped
docker compose pull
docker compose up -d
docker compose logs -f timestampgit
The application is available at http://localhost:8080 after startup. On first launch, a setup wizard walks through connecting your GitHub App and configuring the instance.
Self-hosting requires a license. A time-limited demo license is available by submitting the request form on the Docker License page with your name, company, email, and optional phone number.
FAQ
Is cryptographic prior art legally recognized?
Cryptographic prior art provides mathematically verifiable proof that your code existed at a certain time. While legal recognition varies by jurisdiction, it can be used as evidence in patent disputes and IP litigation. Consult with a legal professional for advice specific to your situation. For a deeper compliance-oriented treatment, read Is a Bitcoin Timestamp Admissible as Evidence?
Do I need to change my development workflow?
No. Timestamp GIT works via a GitHub App that you install once. It automatically timestamps every commit in monitored repositories each night. There are no CLI tools to run and no manual steps required.
What happens if Timestamp GIT shuts down?
Your proofs are vendor-independent. The .ots receipt files can be verified against the Bitcoin blockchain using standard OpenTimestamps tools, even if Timestamp GIT no longer exists. The proofs are embedded in Bitcoin and remain immutable.
How much does Timestamp GIT cost?
Timestamp GIT offers a free tier for public repositories, a Pro Agency plan at $49/month for private repositories, and an Enterprise ZK plan at $199/month that uses GitHub Actions for zero-knowledge timestamping. Current details are on the pricing page.
Conclusion
Cryptographic prior art is not a legal strategy you deploy after a demand letter arrives — it’s infrastructure you put in place while nobody is asking questions. The cost of setting it up is one GitHub App installation. The cost of not having it is whatever a patent troll decides your settlement is worth.
Timestamp GIT’s pitch is precisely that asymmetry: install the app once, let the nightly cron anchor your commit hashes into Bitcoin, and keep the receipts. No CLI, no manual transactions, no workflow change. Your source code never leaves your environment — only fingerprints travel.
Start with the free tier on a public repository and watch a full daily cycle complete. Once you’ve seen a manifest land in your timestamps branch and verified it in the browser, the argument makes itself. Set it up at timestampgit.dev.
Related posts
- Is a Bitcoin Timestamp Admissible as Evidence? A Compliance Guide
- How to Prove You Shipped a Feature Before a Competitor
- Patent vs Timestamp: The Cheapest Way to Protect Source Code IP