Do Git Commit Timestamps Hold Up as Proof?
Open a terminal, run git log, and every commit is staring back at you with a date. It feels authoritative — a permanent, machine-generated record that the code existed at that moment. So when a question comes up weeks or years later (“who had this first?”, “when was this actually shipped?”), it’s tempting to treat those dates as evidence.
They aren’t. Not in the sense that matters when a lawyer, an auditor, or a former employee is on the other side of the table.
This article answers the question directly — do Git commits have timestamps you can trust? — and then shows what a timestamp you can trust actually looks like: a commit hash anchored into the Bitcoin blockchain, produced automatically by a GitHub App you install once.
The Short Answer: Git Timestamps Are Not Proof
Git commit timestamps are self-reported metadata. They are set by whichever machine created the commit, they can be changed afterward, and nothing in the Git protocol verifies that they correspond to real-world time.
Concretely:
- Git stores an author date and a committer date as plain fields inside the commit object. Anyone who can create a commit can set them to anything.
- Those fields are not signed by a trusted time source. There is no consensus mechanism, no third party, no witness.
- History can be rewritten: commits amended, rebased, or recreated from scratch with new dates and new hashes.
There’s a second, subtler problem. Even if you never touch the dates, the only copy of “when this happened” lives on infrastructure you don’t control — GitHub’s servers, your CI logs, your laptop’s reflog. In a dispute, internal logs are routinely dismissed as self-serving: of course your system says you did it first, you wrote the system.
So there’s a real distinction to draw:
| Purpose | Git timestamp is… |
|---|---|
| Sorting commits, reading history, bisecting bugs | Perfectly fine |
| Slack messages, changelogs, release notes | Fine |
| Patent disputes, IP ownership claims, payment disputes, audits | Not evidence |
Git timestamps are a workflow convenience. They were never designed to be proof.
Why Git Timestamps Are So Easy to Fake
The clock belongs to you
Git reads the system clock on the machine where the commit is created. Change the clock, change the timestamp:
GIT_AUTHOR_DATE="2019-03-04T10:00:00" \
GIT_COMMITTER_DATE="2019-03-04T10:00:00" \
git commit -m "Feature that definitely existed in 2019"
That commit is a perfectly valid Git object. It will push, clone, and render in the GitHub UI without complaint. Anyone with repository access can do this, and there is no audit trail showing that the date was fabricated.
History is mutable by design
Git’s history is a chain of hashes, but the chain is yours to rebuild:
git commit --amend --date="2019-03-04T10:00:00"
git rebase -i HEAD~10 # reword, squash, reorder, re-date
Rewriting history produces new commit hashes — which is exactly the point. The old hash disappears, the new one carries whatever date you typed, and nothing external witnesses the transition. If you’re wondering whether the content of a commit is tamper-evident (it is — changing a byte changes the hash), that’s a separate property from the date being trustworthy. The hash proves what the code was. It says nothing about when.
The hosting platform isn’t a notary
GitHub records the dates Git hands it. Its logs live on its own servers and are mutable by the platform, by repository admins, and by anyone who rewrites and force-pushes. In a legal context, “our commit history on GitHub says so” is an assertion, not mathematical proof.
The diary analogy
Think of a diary entry versus a notarized document. Both record a date. Both feel official when you read them. But only the notarized one is trusted by a stranger, because a third party with no stake in the outcome confirmed the date and made it impossible to change afterward without detection.
A Git commit timestamp is a diary entry. Cryptographic timestamping is the notary.
What Actually Proves Code Existed at a Specific Time
The mechanism is simpler than it sounds:
- Fingerprint the content. Run a cryptographic hash (SHA-256) over the data. The hash is a fixed-size string that changes completely if a single byte of the input changes.
- Anchor the fingerprint publicly. Write that hash into a ledger that no single party controls and that cannot be rewritten — Bitcoin.
- Keep the receipt. Now anyone holding the original data can re-hash it, match it against the anchored value, and confirm it existed at or before the block’s timestamp.
Bitcoin is the right anchor because it’s decentralized: no company, including the one providing the service, can alter a confirmed block. Once a transaction is buried a few blocks deep, rewriting it would require redoing more work than the network produces.
OpenTimestamps makes this practical at scale. Instead of putting every hash directly on-chain, it batches many hashes into a Merkle tree and commits only the root, so thousands of commits share one Bitcoin transaction — cheap, fast, and privacy-preserving. The result is a small .ots receipt file you can verify independently.
The catch is operational: doing this by hand means running tooling, managing calendars, and handling receipts per batch. That’s the hard way, and it’s precisely what Timestamp GIT automates.
How Timestamp GIT Makes Git Timestamps Trustworthy
Timestamp GIT is a managed service built around a GitHub App. You install the app once on a repository; from then on, every commit is anchored into Bitcoin automatically. No CLI, no scripts, nothing to run on developer machines.
Step 1 — The fingerprint. Git already produces a unique hash for every commit. That hash is a one-way fingerprint of your repository state at that moment.
Step 2 — The anchor. Each night, a worker collects the day’s pending commit hashes, writes them into a per-repository manifest (.txt), builds a Merkle tree, and anchors the Merkle root into a Bitcoin block through public OpenTimestamps calendars. Bitcoin confirmation typically takes around three hours, so the proof files land a few hours after the batch runs.
Step 3 — The proof. The manifest and the corresponding .ots receipt files are pushed back into your repository — in a dedicated timestamps branch, or into a separate shadow repo if you’d rather keep them apart. You now hold a receipt that proves the hashes existed before a specific Bitcoin block.
The guarantees that fall out of this design:
- Zero-knowledge. The service reads commit hashes only. Your source code is never copied, stored, or inspected.
- Vendor-independent. The proof is SHA-256 plus Bitcoin block data. No proprietary format, no lock-in — a third-party OpenTimestamps verifier can check it without our involvement.
- Offline-verifiable. The
.otsfile is self-contained. If the service disappeared tomorrow, the proof would still stand.
For day-to-day confirmation, you don’t even open the receipts. The public status page for a repository shows proof longevity, earliest anchor date, daily regularity, and the Bitcoin block and transaction data — plus a downloadable audit CSV and a PDF certificate per date. There’s a browser-based verification page that walks the Merkle chain step by step, computing everything locally so nobody — including us — sees what you’re checking. And an embeddable Shields.io badge can go straight into your README.
If you want to wire this into your own tooling, the API is straightforward:
# Combined summary (feeds the Shields.io badge)
curl https://timestampgit.dev/api/statusSummary/acme/payments-service
# Latest anchored Bitcoin block
curl https://timestampgit.dev/api/statusLast/acme/payments-service
# Full Merkle chain data for a specific day, for local verification
curl https://timestampgit.dev/api/verify/acme/payments-service/2026-11-15
Private repositories append an encrypted HMAC to these URLs, so status stays visible only to authorized users.
Common Misconceptions About Git and Timestamps
“Git commits are immutable, so the timestamps must be trustworthy.” Immutability applies to content, not metadata. Changing a commit’s date produces a different hash — which is exactly why the date isn’t evidence: you just make a new commit with a new hash and a new date, and the old one vanishes from the branch.
“GitHub’s commit history is proof enough.” Platform logs aren’t cryptographically anchored to anything outside the platform. They can be rewritten by admins and force-pushes, and they’re frequently dismissed in disputes as self-reported.
“Blockchain timestamping requires deep crypto knowledge or manual tooling.” Doing it raw does. Using a managed service doesn’t: install the GitHub App, and anchoring happens on a nightly schedule you never think about. The cryptography is real; the operational burden is zero.
“Timestamping exposes my code.” Only hashes leave your repository. A hash of a commit reveals nothing about its contents — you can’t reverse it, and you can’t compare it against anything without already having the original.
When You Need Cryptographic Proof (and When You Don’t)
For everyday development, Git timestamps are fine. You are not going to anchor every bugfix branch, and you shouldn’t.
Reach for cryptographic proof when a date might have to survive an adversarial conversation:
- Patent disputes. A non-practicing entity files a broad patent on something you shipped months earlier. Anchored prior art is how you invalidate the claim. (More on that in Cryptographic Prior Art: The Startup Shield Against Patent Trolls.)
- Employee IP claims. A departing lead developer disputes when a feature was conceived. An immutable timestamp ends the he-said-she-said.
- Client payment disputes. Agencies can prove delivery dates instead of arguing about invoice timelines.
- Freelance plagiarism. Prove a library or portfolio piece was yours first.
- Compliance and audits. Show a verifiable, third-party-anchored record of when code changed — without handing over source.
Whether such a proof is admissible depends on jurisdiction and circumstances; that’s a conversation for your lawyer, and we cover the nuances in Is a Bitcoin Timestamp Admissible as Evidence?.
Pricing reflects that split: timestamping is free for public open-source repositories, with paid plans for private repos and larger teams.
Running it inside your own network
For regulated environments or air-gapped setups, Timestamp GIT ships as a Docker image you host yourself. 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 app comes up at http://localhost:8080; a setup wizard on first launch walks you through connecting your GitHub App. A time-limited demo license is available via the request form on the Docker License page. Full deployment details live in Self-Host Git Timestamping With Docker Compose.
FAQ
Can I just change my system clock to fake a Git commit date? Yes. Git uses your local clock, and you can set it to any date — or rewrite the date afterward with an amend or rebase. That’s exactly why Git timestamps alone aren’t reliable proof of anything.
Does GitHub provide trustworthy timestamps for commits? GitHub records the dates Git supplies, but they aren’t cryptographically anchored. Its logs live on its own servers, can be altered, and can be dismissed as self-serving in a legal context.
How does Timestamp GIT prove my code existed at a certain time without seeing my code? It only processes commit hashes — cryptographic fingerprints of your repository state. Those hashes are batched and anchored into Bitcoin via OpenTimestamps. Your source code never leaves your repository.
Is the proof from Timestamp GIT admissible in court? The proof rests on Bitcoin’s immutable ledger and standard SHA-256 hashing, which are increasingly recognized in legal contexts. Admissibility still depends on your jurisdiction and specific circumstances — consult a legal professional. For a deeper discussion, see our article on Bitcoin timestamp admissibility.
The Bottom Line
Git commit timestamps answer “in what order did these changes happen on this machine?” They do not answer “can you prove to a stranger that this code existed on this date?” For the second question you need a fingerprint anchored somewhere you don’t control — and the practical way to get that is to stop treating timestamps as a manual chore.
Install the GitHub App once, let the nightly batch do its work, and every commit in the repository becomes backed by a Bitcoin block. You can see the whole flow — and the verification pages and badges that come with it — at timestampgit.dev.
Related posts
- Automatic Git Commit Timestamping Without Any CLI
- OpenTimestamps vs Timestamp GIT: Manual Proofs or GitHub App?
- Self-Host Git Timestamping With Docker Compose