Are Git Commit Timestamps Reliable for Legal Proof?
If you are a developer or a compliance lead, you have probably asked some version of this: my commit history clearly shows I built this feature two years ago — isn’t that enough proof?
The honest answer is: it depends on who controls the clock. A commit timestamp written by your machine and stored in your repository is a claim about the past. A commit hash anchored into a public, immutable ledger is evidence about the past. Those two things look similar in git log and behave very differently in a dispute.
This article explains the difference, why it matters when patent claims, employee departures, or “we built it independently” defenses show up, and how to get anchored timestamps without changing how your team writes code.
The Short Answer: It Depends on Who Controls the Clock
Every Git commit carries two timestamps — an author date and a committer date — plus a hash. All three live in a file inside your repository. Whoever can rewrite that file controls the timestamp.
That single fact drives the whole legal question:
- Self-reported timestamp — produced by your machine, pushed to your GitHub account, stored in a repo you or your host can rewrite. Trustworthy for engineering, weak as evidence, because the party presenting it also controls it.
- Externally anchored timestamp — a cryptographic proof of the commit hash’s existence, embedded into a public, immutable ledger at a specific point in time. Verifiable by anyone, including your opponent, without trusting you.
The practical takeaway for developers and compliance teams is short: Git history alone is weak evidence. Git history plus an independent cryptographic anchor is strong evidence.
The rest of this article covers why that distinction exists, what the anchor actually is, and how to get it automatically.
Why a Normal Git Log Is Weak Evidence
Start with what a commit actually contains:
git log -1 --format='author: %ad%ncommitter: %cd%ncommit: %H' --date=iso
Output looks like this:
author: 2026-03-14 09:12:44 +0100
committer: 2026-03-14 09:12:44 +0100
commit: a3f9c1e7b2d4... (abbreviated)
Nothing here is protected. A rebase, an amend, or a force-push rewrites these values freely:
git commit --amend --no-edit --date="2026-01-02T08:00:00"
git push --force-with-lease
Three structural problems follow from that:
- The “self-serving record” problem. In an audit or a courtroom, internal logs and screenshots are frequently dismissed because the party presenting them also produced and stores them. A record you can silently edit is not independent evidence.
- Hosting dependency. Standard Git history lives on servers you do not own — GitHub, GitLab, an internal VPS — or in databases you can write to. Provenance is not independently verifiable by a third party.
- No external witness. Even an honest timeline has nothing outside your infrastructure confirming that the commit existed on that date.
The consequences are concrete. Patent trolls file broad claims on technology you shipped months earlier, and without dated proof you face litigation you should have been able to end early. When a lead developer leaves, “I conceived that feature” becomes a he-said, she-said fight. A competitor claims a “clean room” independent build of the same feature, and you have nothing that establishes you had the finished logic 18 months before.
A Real-World Analogy: Notarizing a Sealed Envelope
Think about a notary public. You hand over a sealed envelope. The notary does not open it, read it, or keep a copy. They certify one narrow fact: this envelope, in this exact state, existed at this moment — and their record can be checked later by a third party.
Cryptographic Git timestamps map onto that model almost exactly:
| Notary analogy | Git reality |
|---|---|
| Sealed envelope | The commit hash — a fingerprint of your exact repository state |
| Notary stamp and ledger | A public, immutable ledger that records the hash’s existence |
| “I don’t need to read it” | Zero-knowledge: only the hash is processed, never your source code |
| Anyone can verify the seal | Independent verification without trusting you or the service |
The critical property is independence. A notary who worked for you, stored their own records, and could re-issue stamps on request would be worthless in court. The same is true here: the witness has to be public and immutable, and the verification has to work even if the witness’s operator disappears.
How Cryptographic Git Timestamps Actually Work
The mechanism has three steps. None of them require you to read your own source code into a third-party system.
Step 1 — The fingerprint
Git already generates a one-way SHA-1 or SHA-256 hash that represents the exact state of your entire repository at that commit. Change one byte and the hash changes completely. This is a cryptographically secure fingerprint of your work at that moment — nothing more needs to be extracted.
Step 2 — The anchor
Commit hashes are collected into a daily manifest text file per repository, hashed into a Merkle tree, and the Merkle root is embedded into a Bitcoin transaction using the OpenTimestamps protocol. That freezes the hash’s existence in time, recorded immutably in a specific Bitcoin block.
In a managed pipeline, this runs on a schedule: commit hashes land in a queue during the day, a midnight worker batches them, builds the Merkle tree and the proofs, and anchors the root. Confirmation in Bitcoin typically takes around three hours, so proofs appear a few hours after the batch runs.
Step 3 — The proof
You receive an immutable .ots receipt file alongside the manifest. That receipt lets you prove — to a lawyer, an auditor, or a court — that your idea existed on a specific date. The proof rests entirely on SHA-256 and Bitcoin block data, so it can be verified offline and independently.
Three guarantees come out of this design:
- Zero-knowledge — your source code is never seen, copied, or stored. Only the Git hash is stamped.
- Vendor independent — no proprietary format, no lock-in. Verification depends on public cryptography and Bitcoin block data.
- Court-ready standards — globally recognized cryptographic primitives, not a vendor’s private log.
Why This Matters for IP Disputes (and Common Misconceptions)
Anchored timestamps change the shape of three common disputes:
- Patent claims. A cryptographically dated record of you implementing something before a filing is prior art that can invalidate broad claims.
- Employee conception disputes. “When was this feature conceived?” stops being a memory contest and becomes a checkable timeline.
- “Independent development” defenses. Proof that you had the finished logic 18 months earlier is a wall a clean-room story cannot climb.
Three misconceptions keep coming up.
Misconception 1: “My GitHub commit history is enough.” Hosted history is editable and controlled by a party with an interest in the outcome. It is useful context. It is not independent evidence.
Misconception 2: “I need to learn OpenTimestamps and Bitcoin transactions.” The hard way exists — manually assembling proofs and broadcasting transactions is possible. For most teams it is unnecessary overhead, and it is exactly the kind of thing that gets skipped under deadline pressure. (For background on what the proofs represent legally, see What Is Cryptographic Prior Art? A Guide for Software Teams.)
Misconception 3: “The timestamping service can see my code.” Only commit hashes are processed. The zero-knowledge model means source code never leaves your control — and in the enterprise mode described below, the service never even needs read access to the source repository.
The Practical Path: Automated, Zero-Setup Timestamping with Timestamp GIT
Timestamp GIT is a managed SaaS plus GitHub App that fully automates and hides the OpenTimestamps protocol. You install the GitHub App once. Every commit to a monitored repository is then anchored into Bitcoin automatically each night — no CLI tools, no protocol commands, no manual steps, and nothing installed on your developers’ machines.
There are two deployment modes:
- Standard Mode (GitHub App). The app reads only the HEAD commit hash of the monitored repository, then writes proofs into a dedicated timestamps branch — either in the same repository as the source or in a separate shadow repository. GitHub’s permission model means the app needs at least read-only access to the source repo (there is no commit-hash-only permission) and read-write access to the target repo.
- Enterprise ZK Mode. A 12-line GitHub Action runs inside your own infrastructure and pushes only the commit hash to the Timestamp GIT API. Your source never leaves your environment, and the service requires no read access to the source repository at all — only read-write access to the target repo for proof delivery.
What you get back is built for compliance work, not just for engineering:
- Verification badges you can embed in your README, with a public link anyone can check. The badge widget has a live preview so you can see the Shields.io badge before you commit it.
- A public status dashboard per repository — proof longevity, earliest anchor date, daily regularity, the Bitcoin block and transaction data, a calendar heatmap, and downloadable audit CSV plus a PDF certificate.
- A REST API for automation:
GET /api/statusSummary/{user}/{repo}for badge data,GET /api/audit/{user}/{repo}for the full audit ledger as CSV,GET /api/report/{user}/{repo}/{date}for a per-date PDF certificate, andGET /api/verify/{user}/{repo}/{date}for the full Merkle chain data for local verification.
curl -s https://timestampgit.dev/api/statusSummary/your-user/your-repo
Private repositories append an encrypted HMAC to the URL, so only authorized users can read a private repo’s status — that HMAC is specific to the server instance.
For air-gapped or maximum-security environments, Timestamp GIT is also available as a Docker self-hosted 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 walks you through connecting your GitHub App and configuring the instance. A time-limited demo license for evaluation can be requested from the Docker License page; you submit your name, company, email, and optional phone number, and download the demo license file.
Compare that to the manual route — wiring up the protocol yourself, handling batching, Merkle trees, proof delivery, and verification tooling — and the managed workflow is the difference between one installation step and an ongoing engineering project.
FAQ
Can I just use my GitHub commit history as proof in a legal dispute?
GitHub history is useful context but is generally treated as self-reported and editable, so it is often dismissed as self-serving in an audit or court. Cryptographic anchoring adds an independent, immutable timestamp that anyone can verify against a public ledger, which is what makes it court-ready evidence.
Does Timestamp GIT see or store my source code?
No. The service operates on a zero-knowledge model: it processes commit hashes, never your actual source code. In Standard Mode the GitHub App reads only the HEAD commit hash. In Enterprise ZK Mode, a 12-line GitHub Action running in your own environment pushes only the hash, which means the service needs no read access to your source repository.
What happens if Timestamp GIT shuts down? Can I still prove my timestamps?
Yes. The proof relies only on SHA-256 and Bitcoin block data via the OpenTimestamps protocol, so it is vendor-independent. You can download your .ots receipt files and verify them locally against the Bitcoin blockchain using standard verification tools, even if the company disappears. For a walkthrough, see How to Verify a Bitcoin Timestamp Proof Locally.
Do I need to install anything on my developers’ machines or learn OpenTimestamps?
No. Timestamp GIT is a managed GitHub App: you install it once, and every commit to a monitored repository is anchored into Bitcoin automatically each night. There are no CLI tools, no protocol commands, and no manual steps for your developers. For air-gapped environments, a Docker self-hosted option is available.
The Bottom Line
A Git commit timestamp is only as reliable as the clock behind it. If that clock is your own server or your hosted account, expect an opponent to call it self-serving. If that clock is a public, immutable ledger that anyone can verify without trusting you, the timestamp becomes evidence.
Git history plus cryptographic anchoring is the combination that holds up. The only remaining question is how much work you want to spend maintaining it.
Install the GitHub App once, connect a repository, and let nightly anchoring handle the rest — then check your badge, your status dashboard, and your first .ots receipt the next morning.
Related posts
- How to Verify a Bitcoin Timestamp Proof Locally
- GitHub App That Timestamps Commits Automatically
- How Freelancers Can Prove Code Ownership Before a Dispute