How to Independently Verify a Git Commit Timestamp
A timestamp you cannot check yourself is not proof — it is a promise from a vendor. That distinction matters the moment someone else asks you to prove when your code existed: a compliance auditor, opposing counsel in a patent dispute, or an acquirer doing technical due diligence.
This article shows how to verify a Git commit timestamp independently using Timestamp GIT’s proof artifacts and tooling: the public status page, the browser-based Merkle verification page, the REST API, verification badges, and downloadable reports. No source code needs to leave your repository, and no one — including the vendor — has to be trusted for the result to hold.
Why Independent Verification Matters
Every cryptographic timestamp is only as strong as your ability to audit it on your own terms.
- Verification must not depend on the vendor staying alive. Timestamp GIT proofs rely solely on SHA-256 and Bitcoin block data. You can verify them offline, even if the service no longer exists.
- Regulators, auditors, and courts expect reproducible evidence. “The dashboard said so” is not evidence. A Merkle root matched against a Bitcoin block is.
- Due diligence asks hard questions. During an acquisition or a funding round, IP maturity is examined. Being able to hand over a verifiable proof chain is very different from handing over a screenshot.
- Your source code stays private. Verification needs exactly two things: the proof files (manifest and
.otsreceipt) and public blockchain data. Not your implementation, not your trade secrets.
The rest of this article is the practical checklist.
What a Timestamp GIT Proof Looks Like
A single day of commits produces a small, well-defined set of artifacts:
- A daily manifest file (
.txt) containing the commit hashes collected for that repository on that day. - A Merkle root computed over the manifest. The root is the single value that represents every commit in the batch.
- An
.otsreceipt file — an OpenTimestamps proof that cryptographically links that Merkle root to a specific Bitcoin block.
These artifacts live in a dedicated timestamps branch or a shadow repository, deliberately separated from your source code. That separation is the point: the proof travels independently of the code it protects.
Alongside the files, the record includes the Bitcoin block height and transaction ID that anchored the batch. Those two values are what let anyone — you, a lawyer, an external auditor — confirm that the data existed when the block was mined.
Step-by-Step: Verifying with Timestamp GIT’s Tools
Timestamps are produced automatically: install the GitHub App once, connect the repository, and every commit is anchored each night with no manual steps. Verification is where you take over — and you have five ways to do it.
1. The public status page
Open https://timestampgit.dev/status/{user}/{repo}. This dashboard shows:
- proof longevity and the earliest anchor date,
- daily regularity (a calendar heatmap makes gaps obvious),
- the Bitcoin block height and transaction ID for each anchor.
It is the fastest sanity check. If a counterparty questions continuity, the heatmap is the answer.
2. The browser-based verification page
For a specific day, go to https://timestampgit.dev/verification/{user}/{repo}/{date}. This page walks through the multi-level Merkle chain step by step and performs all computation locally in your browser — zero-knowledge. Nobody sees what you verify, which is useful when the repository itself is confidential.
This is the page to open in front of an auditor, because each level of the chain is shown, not summarized.
3. The verification API
When verification needs to be scripted or archived, pull the raw chain:
curl -s "https://timestampgit.dev/api/verify/acme-corp/payments-api/2026-10-05" \
-H "Accept: application/json" | jq .
The response contains the full Merkle chain data for that day’s timestamp so you can recompute it locally instead of trusting the rendered page.
4. Verification badges
On the repository connection page you get an embeddable Shields.io badge plus its markdown snippet. Drop it in your README:
[](BADGE_LINK)
Anyone clicking the badge lands on the verification view for your repository. It is a public, always-current claim of proof of existence — and because the link resolves to verifiable data rather than a static image, it is not just decoration.
5. Reports and audit exports
Two endpoints cover the paperwork side:
# Per-day PDF certificate
curl -sL "https://timestampgit.dev/api/report/acme-corp/payments-api/2026-10-05" \
-o certificate-2026-10-05.pdf
# Full audit ledger as CSV
curl -sL "https://timestampgit.dev/api/audit/acme-corp/payments-api" \
-o audit-ledger.csv
The PDF is what you attach to a legal filing. The CSV is what you feed into an internal audit archive or a spreadsheet you hand to a diligence team.
Note that private repositories append an encrypted HMAC to their URLs, so only authorized users can open their status and verification pages. The proof underneath is unchanged — it is still anchored in Bitcoin and still verifiable by anyone holding the proof file.
Interpreting Verification Results and Edge Cases
A successful verification means one specific thing: the Merkle root you recomputed from the manifest matches the value anchored in the Bitcoin block referenced by the .ots receipt. That match proves the set of commit hashes existed no later than that block’s timestamp. It does not matter who runs the check or where.
Four edge cases are worth knowing before you promise anyone a verification result:
- The current day is probably not verifiable yet. Anchoring runs nightly, and Bitcoin confirmation takes several hours (normally around 3 hours). A proof for today’s commits may not exist yet, and the previous night’s batch may still be pending confirmation. Plan audits around this window.
- Private repositories require the HMAC. Verification works exactly as it does for public repos, but the URL carries an encrypted HMAC specific to the server instance. No HMAC, no status page.
- A timestamp proves existence, not authorship. The proof says a commit hash existed at a specific time. It does not, by itself, establish who wrote the code or that the code is novel. Use it as prior-art evidence, not as a substitute for a chain of title.
- Anyone can verify, even without Timestamp GIT. Because the proof is built on open standards, a sufficiently motivated engineer can verify the
.otsfile with standard OpenTimestamps tools against the Bitcoin blockchain. That is a feature: it means your evidence survives the vendor.
Verifying Without the SaaS: The Hard Way (and Why You Don’t Need It)
In principle you could assemble this pipeline yourself — run the OpenTimestamps tooling, query Bitcoin nodes, reconcile Merkle proofs by hand. In practice that means maintaining infrastructure and expertise for a task that is not your product.
Timestamp GIT exists so you don’t have to. Install the GitHub App once on a monitored repository and every commit is anchored into Bitcoin automatically each night — no CLI, no manual steps, no protocol knowledge required. Verification is then a link, a badge, or an API call. For organizations that need to keep everything on their own hardware, self-hosting is available as a Docker image:
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 reachable at http://localhost:8080, and a setup wizard walks you through connecting your GitHub App and configuring the instance on first launch.
Automating Verification in Your Workflow
Manual verification is fine for disputes. For ongoing compliance, automate it.
Gate your CI/CD on anchor status. The combined summary endpoint is designed for exactly this:
curl -sf "https://timestampgit.dev/api/statusSummary/acme-corp/payments-api" -o summary.json
cat summary.json
A small check script turns it into a build gate:
import json
import sys
import urllib.request
URL = "https://timestampgit.dev/api/statusSummary/acme-corp/payments-api"
with urllib.request.urlopen(URL) as response:
summary = json.load(response)
print(json.dumps(summary, indent=2))
# Fail loudly if the summary reports no anchored Bitcoin block yet.
if not any("block" in key.lower() for key in summary):
sys.exit("No Bitcoin anchor reported for this repository yet.")
Wire it into a scheduled workflow so a missing anchor becomes a ticket instead of a surprise during an audit:
name: Timestamp anchor check
on:
schedule:
- cron: "0 8 * * *"
workflow_dispatch:
jobs:
verify-anchor:
runs-on: ubuntu-latest
steps:
- name: Check anchor status
run: |
curl -sf "https://timestampgit.dev/api/statusSummary/${{ github.repository_owner }}/${{ github.event.repository.name }}" \
-o summary.json
cat summary.json
Archive proofs on a schedule. Pull the audit CSV monthly and store it in your records system:
curl -sL "https://timestampgit.dev/api/audit/acme-corp/payments-api" \
-o "audit-ledger-$(date +%Y-%m).csv"
Publish the badge. It costs one line in your README and gives counterparties a self-service way to check your claims.
If keeping repository contents out of the service is a requirement, the Enterprise ZK deployment mode runs a short GitHub Action on your own infrastructure that pushes commit hashes to the Timestamp GIT API. Verification behaves the same; only the ingestion path changes.
FAQ
Do I need to trust Timestamp GIT to verify a timestamp?
No. The proof relies solely on SHA-256 and Bitcoin block data. You can verify it independently using the .ots file and standard OpenTimestamps tools against the Bitcoin blockchain, even if Timestamp GIT no longer exists.
How long does it take for a commit timestamp to become verifiable? After the nightly anchoring process, the proof is written to your repository. Bitcoin confirmation typically takes around 3 hours, after which the timestamp is immutable and verifiable.
Can I verify a timestamp for a private repository? Yes. Private repositories use an encrypted HMAC appended to the URL, so only authorized users can access the status page and verification tools. The underlying proof is still anchored in Bitcoin and can be verified by anyone with the proof file.
What tools does Timestamp GIT provide for verification? A public status page, a browser-based verification page that computes everything locally, REST API endpoints for Merkle chain data and audit reports, and embeddable Shields.io badges. All are designed for independent verification without vendor involvement.
Conclusion
Independent verification is what separates a timestamp from a marketing claim. With Timestamp GIT, you get the proof chain from the status page, recompute the Merkle path in your browser, script the same check in CI, and export a PDF certificate for the file — all without exposing a single line of source code.
If you want that running on your repositories, the managed service is a one-time setup: install the GitHub App, connect the repo, and let the nightly anchoring do the rest. For air-gapped or self-hosted requirements, the Docker self-hosted license covers that path too. Start at timestampgit.dev and verify a repository for yourself.
Related posts
- Automatic Nightly Git Commit Anchoring to Bitcoin, Zero Manual Steps
- Code Timestamping Service Pricing for Private Repos
- OpenTimestamps Alternatives: Managed Git Timestamping