Timestamp GIT

← All posts

2026-10-27

How to Prove Prior Art for a Software Idea Without a Patent

How to Prove Prior Art for a Software Idea Without a Patent
timestamp git blockchain proof

How to Prove Prior Art for a Software Idea Without a Patent

You shipped the feature. Eighteen months later, someone files a patent on it and your company gets a letter. Or a client stops paying and claims the work was never delivered. Or a competitor says they built the same thing independently.

In every one of those situations, the question is the same: can you prove your idea existed on a specific date?

This is what “prior art” means in software, and the answer does not require a patent attorney, a filing fee, or publishing your source code. It requires a fixed, verifiable point in time that you can hand to a lawyer, an auditor, or a court. This article explains what that actually looks like and how to get it with a single GitHub App installation.

What Does “Proving Prior Art” Actually Mean for Software?

Prior art is evidence that an idea, implementation, or design already existed before someone else’s claim to it. In patent law it’s the body of knowledge the examiner (or a judge) checks a claim against. Outside the courtroom, it’s simply proof of existence at a date.

Software makes this awkward for three reasons:

  • Code is a moving target. Your repository on any given day is a different artifact than it was yesterday. “We had this in 2025” is not evidence; a hash of a specific commit on a specific date is.
  • Your history lives on infrastructure you don’t control. GitHub’s servers, your laptop’s clock, an editable database. Any of those can be rewritten, and opposing counsel knows it.
  • The proof has to survive you. A timestamp that only your vendor can verify is not proof — it’s a promise.

The key clarification: you do not need a patent to have prior art. A patent is a monopoly grant. Prior art is a defensive fact. Anyone who can prove they built something first holds prior art, whether or not they ever filed anything.

That proof gets used in two directions:

  • Defensively — to invalidate or deter a broad patent claim from a non-practicing entity, or to show a feature was already in production before a competitor’s filing.
  • As leverage in disputes — payment disagreements with clients, authorship disputes when a lead developer leaves, or a competitor’s “clean room” story that falls apart when you can show finished logic from 18 months earlier.

The Notary Analogy: How Cryptographic Timestamping Works

A notary public does one useful thing: they confirm that a document existed on a given date, and they seal it. That seal travels with the document and carries weight in court.

The weakness is human. A notary can be mistaken, bribed, or presented with a backdated document. Their records live in a filing cabinet or a database that someone administers.

Cryptographic timestamping replaces the notary with arithmetic:

  • There is no one to bribe, because there is no one who decides what the timestamp says.
  • There is nothing to forge, because the seal is derived from your exact content and anchored in a public ledger replicated across thousands of machines.
  • There is nothing to lose, because verification doesn’t depend on the vendor staying in business.

The mechanism is three steps, and the names matter because they show up in every receipt you’ll receive.

1. The fingerprint. Git already computes a unique one-way hash (SHA-1 or SHA-256) for every commit, representing the exact state of your repository at that moment. This hash is your fingerprint. It reveals nothing about the contents.

2. The anchor. Timestamp GIT collects only those commit hashes — never the code — batches them into a daily manifest per repository, hashes the batch again, and anchors that value into a Bitcoin transaction using the OpenTimestamps protocol. The hash’s existence is now frozen in a specific Bitcoin block.

3. The proof. You get an immutable .ots receipt file. With it, you can demonstrate mathematically that the fingerprint existed at or before that block’s timestamp. The proof is self-contained: SHA-256 plus Bitcoin block data.

The zero-knowledge property is the part compliance teams care about most. Only fingerprints leave your environment. Your source code is never read, copied, or stored.

Under the Hood: From Git Commit to Bitcoin Block

Here’s what actually happens between your git push and a verifiable receipt, in the standard deployment mode:

  1. Commit detection. The Timestamp GIT GitHub App watches your monitored repository and reads the HEAD commit hash as new commits arrive. No developer installs anything; no one runs a command.
  2. Hash queue. Hashes land in an in-memory key-value store and wait for the next batch.
  3. Midnight cron worker. Each night a worker groups the pending hashes, writes a .txt manifest per repository, builds a Merkle tree natively, creates OpenTimestamps proofs against public OTS calendars, and anchors the Merkle root into Bitcoin.
  4. Proof delivery. The manifest and .ots receipt files are pushed back into a dedicated timestamps branch in your repo (or a separate shadow repository you nominate).
  5. Confirmation. Bitcoin block confirmation typically takes around three hours, so proof files appear a few hours after the nightly run. After that, the record is immutable — no entity, including Timestamp GIT, can alter it.

Two deployment modes exist, and the difference is purely about repository access:

  • Standard (GitHub App). The app needs read-only access to the source repository (GitHub has no “commit hash only” scope) and read-write access to the target repository where proofs are written.
  • Enterprise ZK mode. A 12-line GitHub Action runs on your infrastructure and pushes only the commit hash to the Timestamp GIT API. Only read-write access to the target repo is required, and no read access to source is granted at all.

There is one honest caveat about the underlying protocol: doing this by hand — generating hashes, submitting to calendars, managing the Merkle proofs yourself — is genuinely tedious and easy to get wrong. That’s the reason to automate it rather than a reason to learn the command line.

Why Bother? Common Misconceptions and Real Benefits

Misconception: “Git commits are already timestamped.”

Every commit carries an author and committer date. Those dates come from the machine that made the commit. They’re trivially editable, and history can be rewritten with a force-push. Server-side timestamps from a hosting provider are better, but in a legal audit, internal logs are routinely dismissed as self-serving or manipulatable. A timestamp with an interested party behind it is not proof of anything.

Misconception: “I need a patent to protect my idea.”

Patents cost real money, take years, and publish your design to the world. What most teams actually need is the ability to invalidate someone else’s claim and to show a documented timeline. Prior art does both. For trade secrets, prior art is often the safer route — you get provable existence without publishing anything.

Misconception: “Timestamping means someone sees my code.”

Only the hash is anchored. A SHA-256 digest of your repository state tells an observer nothing about what’s inside — it’s one-way. In Enterprise ZK mode even the hash moves from your infrastructure via your own Action.

The real benefits

  • Court-ready evidence. The proof rests on globally recognized cryptographic standards and public Bitcoin block data, verifiable offline by any third party.
  • Vendor independence. No proprietary format, no lock-in. If Timestamp GIT disappeared tomorrow, the .ots files you already hold remain verifiable.
  • Low cost, zero friction. Compare the price of a managed GitHub App against patent filings, legal discovery, or losing a payment dispute. The Free tier covers public repositories; Pro Agency covers private repos at $49/mo; Enterprise ZK with GitHub Actions runs $199/mo.
  • Public credibility. Embeddable badges in your README show a live verification status — useful in due diligence and in client-facing work.

How to Implement Prior Art Proof with Timestamp GIT

The whole point of Timestamp GIT is that prior art protection becomes a background process rather than a project. Four steps:

Step 1: Install the GitHub App

Install the app on the repositories you want monitored and accept the standard permission prompts. Nothing is installed on developer machines. If your organization forbids source-repo read access, use Enterprise ZK mode instead: drop the provided GitHub Action into your workflow and it will push only commit hashes outward.

Step 2: Keep committing

No change to your workflow. The nightly cron worker picks up pending hashes, builds the Merkle tree, and anchors the root. Branching, rebasing, and force-pushing your working branches don’t interfere — the hashes were already captured.

Step 3: Collect receipts and badges

After the nightly run and the roughly three-hour Bitcoin confirmation, your proofs appear in the dedicated timestamps branch or shadow repository. Commit that branch to your internal audit archive if your compliance policy requires a second copy.

Step 4: Prove existence on demand

Every repository gets a public status dashboard showing proof longevity, the earliest anchor date, daily regularity, and the Bitcoin block and transaction data behind each day. For a specific date, the verification page walks the Merkle chain step by step, and all computation happens locally in the browser — nobody sees what you verify.

The same data is available programmatically:

# Combined summary (also feeds the Shields.io badge)
curl -s https://timestampgit.dev/api/statusSummary/acme/payments-service

# Full Merkle chain for one day, for local verification
curl -s https://timestampgit.dev/api/verify/acme/payments-service/2026-10-26

# Audit ledger as CSV, or a PDF certificate for a single date
curl -L -o audit.csv https://timestampgit.dev/api/audit/acme/payments-service
curl -L -o cert.pdf  https://timestampgit.dev/api/report/acme/payments-service/2026-10-26

Private repositories append an encrypted HMAC to the URL, so only authorized users can read their status — the HMAC is specific to the server instance.

Air-gapped and self-hosted option

For environments where nothing may leave the network, Timestamp GIT ships as a Docker image. 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, and a first-launch setup wizard guides you through connecting your GitHub App and configuring the instance. A time-limited demo license is available by submitting the request form on the Docker License page.

FAQ

Do I need to change my development workflow to use Timestamp GIT?

No. Once you install the GitHub App, every commit to a monitored repository is automatically anchored each night. You continue working as usual — no CLI commands or manual steps.

Is my source code exposed to Timestamp GIT?

No. Timestamp GIT only reads the commit hash (a cryptographic fingerprint), never your source code. In Enterprise ZK mode, a GitHub Action pushes only the hash, so the service never has read access to your repository.

Can I verify the timestamp independently without Timestamp GIT?

Yes. You receive .ots receipt files that can be verified using standard OpenTimestamps tools against the Bitcoin blockchain. The proof relies only on SHA-256 and Bitcoin block data — no proprietary technology.

What if I use a Git provider other than GitHub?

Timestamp GIT currently integrates via GitHub App or GitHub Action. For other providers, you can self-host the Docker image and adapt the workflow, but native support is GitHub-focused.

The Bottom Line

Proving prior art for a software idea without a patent comes down to one thing: a fixed, tamper-evident record of existence that a third party can verify without trusting you. Notary seals and internal logs don’t clear that bar. A commit hash anchored in Bitcoin does, and you don’t have to run any of the machinery yourself.

Install the GitHub App once, keep shipping, and let the nightly job build the evidence trail you’ll be glad exists the day someone challenges your timeline. Start at timestampgit.dev and connect your first repository — the free tier covers public repos, so there’s nothing to evaluate but the setup time.

Related posts

EU label: AI-generated content