Timestamp GIT

← All posts

2026-10-23

Are GitHub Commit Timestamps Admissible in Court?

Are GitHub Commit Timestamps Admissible in Court?
timestamp git blockchain proof

Are GitHub Commit Timestamps Admissible in Court?

If you are searching for whether a GitHub commit timestamp is legally admissible evidence, you are probably past the theory stage. A dispute is open, a deadline is approaching, and someone — a client, a compliance officer, or your own lawyer — has asked you to produce proof that your code existed on a specific date.

The uncomfortable answer is that the timestamp itself is rarely the deciding factor. What decides the question is whether the other side, and the court, can independently verify that timestamp without taking your word for it.

This article covers what makes a commit timestamp defensible, what a court-ready cryptographic proof actually contains, and how to verify one step by step with Timestamp GIT. If you want the deeper background on why plain Git dates are weak evidence in the first place, read Are Git Commit Timestamps Reliable for Legal Proof?. This article stays on verification and admissibility.

Why Admissibility Hinges on Verification, Not Just Timestamps

Standard Git commit metadata — author date and committer date — lives inside the repository. It can be backdated, rewritten, or simply fabricated before the commit is ever pushed. Anyone with a text editor and a rebase can produce a commit that claims to be from last year.

GitHub’s server-side timestamps are a little better, but they are still stored on infrastructure you do not control, in a database you cannot audit, and cannot be checked against anything outside that platform. They are a record, not a proof.

Courts and auditors tend to look for three properties in a piece of technical evidence:

  • Immutability — the record cannot be altered after the fact by any party, including the party presenting it.
  • Independent verifiability — a third party can check the claim without access to your systems or cooperation from your vendor.
  • Not self-serving — the evidence does not depend solely on logs you generated and stored yourself. Internal logs are frequently dismissed as manipulatable for exactly this reason.

That is the distinction that matters: a timestamp is a claim, while a cryptographic proof is a verifiable fact. A claim says “this code existed on March 3rd.” A proof lets anyone recompute the answer themselves and reach the same conclusion.

Timestamp GIT provides the latter. It extracts your Git commit hashes — SHA-1 or SHA-256 fingerprints of your repository state — and anchors them into the Bitcoin blockchain through the OpenTimestamps protocol. Nothing about the result depends on trusting the vendor’s database.

What a Court-Ready Proof Actually Looks Like

The proof chain has four components, and it is worth knowing them by name before you ever need to hand them to a lawyer:

  • The commit hash — the Git-generated fingerprint of the exact repository state at that moment.
  • The daily manifest (.txt) — a text file grouping every commit hash collected for a repository that day. The manifest gets a SHA-256 hash of its own.
  • The Merkle root — the single hash that summarizes the whole day’s batch across repositories.
  • The .ots receipt file — an immutable file cryptographically linking your commit hash to a specific Bitcoin block.

The .ots receipt is the artifact most people mean when they say “the proof.” It is generated using public OpenTimestamps calendars, but the verification path it describes depends only on SHA-256 and Bitcoin block data. That means:

  • It is vendor-independent. No proprietary format, no lock-in, no need for Timestamp GIT to exist in ten years for the proof to be checkable.
  • It is zero-knowledge. Timestamp GIT never sees, copies, or stores your source code. Only the commit hash is stamped.
  • It can be presented in whatever format the audience needs: a PDF certificate for a lawyer or client, a CSV audit ledger for compliance, or the raw .ots file for a technical expert witness.

Step-by-Step: Verifying a Timestamp with Timestamp GIT

Verification should be boring. Here is the actual sequence, from “did anything get anchored?” to “hand this file to opposing counsel.”

1. Check the public repository status page

Open https://timestampgit.dev/status/{user}/{repo}. This dashboard shows proof longevity, the earliest anchor date, daily regularity, and the Bitcoin block and transaction data behind the most recent anchors.

# Same data, machine-readable
curl -s https://timestampgit.dev/api/statusLast/acme/payments-api | jq
curl -s https://timestampgit.dev/api/statusCount/acme/payments-api | jq

statusLast returns the last anchored Bitcoin block info; statusCount returns the total committed and stamped commit count. The combined summary used by Shields.io is available at statusSummary.

2. Embed the verification badge

From the repository connected page (https://timestampgit.dev/connected/{user}/{repo}) you get badge URLs and Markdown snippets with a live preview. Drop the badge into your README so anyone reviewing the repository — including a future auditor — sees the verification status and can follow the link to the verification site.

The authenticated endpoint that returns badge URLs and snippets is:

curl -s https://timestampgit.dev/api/badgeLink/acme/payments-api

3. Walk the Merkle chain for a specific day

For a dated proof, open https://timestampgit.dev/verification/{user}/{repo}/{date}. This page steps through the multi-level Merkle chain from your commit hash up to the daily root and on to the Bitcoin block.

All computation happens locally in the browser. Nobody — including Timestamp GIT — sees what you verify. The same data is available over the API if you want to check it in your own tooling:

curl -s https://timestampgit.dev/api/verify/acme/payments-api/2026-10-22 | jq

4. Pull the records you will actually file

# PDF certificate for one day
curl -sO https://timestampgit.dev/api/report/acme/payments-api/2026-10-22

# Full audit ledger as CSV
curl -sO https://timestampgit.dev/api/audit/acme/payments-api

The PDF is the right artifact for a client or a lawyer. The CSV ledger is the right artifact for compliance and for showing a consistent, unbroken anchoring history.

5. Verify independently, offline

Download the .ots receipt file from your repository’s timestamps branch (or shadow repository) and check it with standard OpenTimestamps verification tooling against the Bitcoin blockchain. This step requires no Timestamp GIT account, no API access, and no network call to the vendor — it is the strongest possible answer to “how do we know your timestamp is real?”

For compliance teams that want this wired into their own dashboards, the same endpoints are callable directly:

const base = "https://timestampgit.dev/api";
const last = await fetch(`${base}/statusLast/acme/payments-api`).then(r => r.json());
const proof = await fetch(`${base}/verify/acme/payments-api/2026-10-22`).then(r => r.json());

console.log(last.bitcoinBlock, proof.merkleRoot);

Private repositories: status URLs append an encrypted HMAC that is specific to the server instance, so only authorized users can view the status of a private repo. The proof itself is still anchored in Bitcoin, and anyone you hand the .ots file to can verify it.

Interpreting Verification Results and Common Edge Cases

A verification page is only useful if you can read it correctly. A few things to know:

  • Confirmed vs. pending. A confirmed Bitcoin block means the timestamp is immutable. Before confirmation — normally around three hours — the proof is pending. Don’t present a pending proof as final.
  • Not yet anchored. If a commit is missing, it most likely belongs to the next nightly batch. The daily cron worker groups all pending hashes at midnight, then builds manifests, the Merkle tree, and the OpenTimestamps proofs. Proof writing itself completes a few hours later, once the Bitcoin confirmation lands.
  • Existence, not authorship. Verification proves your commit hash existed at a point in time. It does not prove you wrote the code, that it is original, or that it is patentable. It is prior-art evidence, not a patent.
  • Quiet days. A repository with no commits on a given date has no proof for that date. The status page’s daily regularity view makes gaps obvious — which is why a consistent anchoring history is more persuasive than a single stamp.
  • Enterprise ZK mode. Some teams cannot let the service touch the source repository at all. In that setup a small GitHub Action runs on your own infrastructure and pushes only the commit hash to the API; the service holds read-write access to the target repo only, never read access to the source. Verification works identically, because the proof is built from the hash.
  • The hash is the anchor. The proof is only as strong as the hash you claim. If the commit hash in your .ots file isn’t the one in your repository history, verification will fail — and that failure is the point. You cannot swap in a different commit after the fact.

How Timestamp GIT Makes Verification Automatic

The alternative to all of this is bookkeeping you will never keep up with: manually stamping hashes, tracking receipts per repository, and hoping nobody force-pushes while you aren’t looking. Timestamp GIT removes that entirely.

You install the GitHub App once. From then on, every commit to a monitored repository is anchored into Bitcoin automatically each night — no CLI tools, no manual steps, nothing installed on developer machines.

  • Standard mode (GitHub App). The app reads only the HEAD commit hash of the repository. Proofs are written into a dedicated timestamps branch or a separate shadow repository. GitHub’s permission model requires at least read-only access to the source repo (there is no commit-hash-only scope) plus read-write access to the target repo.
  • Self-hosted mode. For air-gapped or maximum-security environments, a Docker self-hosted license is available. 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 instance is available at http://localhost:8080, and a setup wizard on first launch walks you through connecting your GitHub App. A time-limited demo license for evaluation can be requested from the Docker License page.

  • API integration. Compliance teams can drive the whole thing from their own dashboards using GET /api/statusLast/{user}/{repo}, GET /api/statusSummary/{user}/{repo}, GET /api/verify/{user}/{repo}/{date}, GET /api/audit/{user}/{repo}, and GET /api/report/{user}/{repo}/{date}.

To be fair to the DIY crowd: you can assemble something like this the hard way with the raw OpenTimestamps command-line tooling and manual Bitcoin transactions. Timestamp GIT exists so you don’t have to — it hides the protocol behind a GitHub App and a nightly cron.

Building an Admissibility-Ready Evidence Trail

Evidence is more convincing when it looks like a practice, not a panic move. Four habits make that difference:

  1. Keep the artifacts together. Store the .ots receipts, PDF certificates, and CSV audit ledgers alongside your repository history — ideally in the timestamps branch where the product already writes them.
  2. Show regularity. A public status page and README badges demonstrate that anchoring happened daily, for months, before the dispute started. Consistent process is much harder to attack than a single backfilled stamp.
  3. Address lock-in up front. The proof is verifiable offline and does not depend on Timestamp GIT continuing to exist. Say that explicitly in your evidence package; it preempts the “your vendor says so” objection.
  4. Match the mode to your risk model. If your source code must never leave your environment, Enterprise ZK mode keeps it there while still producing the same Bitcoin-anchored receipts.

One caveat worth repeating: this article explains the technical verification path, not legal advice. Admissibility rules vary by jurisdiction and by the type of proceeding. Consult your counsel about what your case requires — then hand them a proof they can check without you in the room.

FAQ

Is a GitHub commit timestamp by itself legally admissible?

A standard GitHub commit timestamp is stored on infrastructure you do not control and can be altered or backdated, so it is often treated as self-serving or manipulatable. A cryptographic proof that anchors the commit hash into Bitcoin via the OpenTimestamps protocol is independently verifiable and tamper-evident, which makes it far more likely to be accepted as evidence. Timestamp GIT provides that proof automatically.

How can I verify a Timestamp GIT proof without trusting the company?

Download the .ots receipt file and run standard OpenTimestamps verification tooling against the Bitcoin blockchain. The proof relies only on SHA-256 and Bitcoin block data, so it is vendor-independent and verifiable offline. Timestamp GIT also offers a browser-based verification page where all computation happens locally.

What if my repository is private? Can I still prove a timestamp?

Yes. Timestamp GIT supports private repositories. Status URLs for private repos include an encrypted HMAC so only authorized users can view them. The proof itself is still anchored into Bitcoin and can be verified by anyone you share the .ots file with.

Do I need to run any commands or install anything on developer machines?

No. Timestamp GIT is a managed GitHub App: you install it once, and every commit to a monitored repository is automatically anchored each night. There are no CLI tools or manual steps for your developers. For air-gapped environments, a Docker self-hosted option is available.

Conclusion

Admissibility questions about commit timestamps almost always come down to one thing: can the other side verify it without trusting you? Repository metadata fails that test. A commit hash anchored into Bitcoin and delivered as an .ots receipt, a PDF certificate, and a CSV ledger passes it — and it keeps passing it years later, offline, with or without the vendor in the picture.

Timestamp GIT handles the whole pipeline for you: install the GitHub App once, connect the repository, and let the nightly anchoring run. Start at timestampgit.dev and check your first repository’s status page.

Related posts

EU label: AI-generated content