Automate Bitcoin Timestamping of Every Git Commit
Manual timestamping has the same failure mode as manual backups: it works perfectly until the week you’re busy. And the week you’re busy is exactly the week you ship the feature you’ll later need to prove you shipped.
This article is about removing the human from that loop. Not “remember to stamp before you merge,” not a checklist item in your release runbook — but a one-time install that turns every commit in a monitored repository into a Merkle-batched, Bitcoin-anchored proof, automatically, every night, whether anyone on the team is thinking about IP protection or not.
If you’re still deciding whether cryptographic prior art matters for your situation, see Prove Prior Art Before You File: A Founder’s Guide. This piece assumes you’ve decided, and now want it running on autopilot.
The Manual Timestamping Trap (and Why Automation Wins)
Doing this by hand looks deceptively simple. In practice, a manual workflow means someone on the team must:
- Remember to timestamp after every meaningful commit — before the branch gets rewritten, squashed, or force-pushed.
- Manage key material and proof files locally, in a place that survives laptop wipeouts and staff turnover.
- Store the resulting receipts somewhere durable, versioned, and findable two years later during diligence.
- Repeat for every commit, in every repository, forever.
That last bullet is where manual processes die. Coverage is inconsistent, and inconsistent coverage is worse than it sounds: in a dispute, a gap in your evidence chain invites the argument that this commit — the one that matters — was the exception. One forgotten push on a Friday afternoon can turn a clean timeline into a question mark.
The underlying OpenTimestamps protocol is genuinely well designed, and you can drive it yourself with raw command-line tooling and manual Bitcoin anchoring — the hard way, on your own dime and your own time. For a team that ships daily and has no dedicated crypto person, that’s a maintenance project disguised as a security control.
Automation wins because it converts a recurring decision into a one-time configuration. Install a GitHub App once, and from that moment every commit to the monitored repository is captured, queued, batched, anchored, and filed back into your repo without a developer touching anything.
One-Time Setup: Install the GitHub App and Forget It
Setup is the shortest part of this article, which is the point.
- Install the Timestamp GIT GitHub App. Pick a single repository or grant it to your whole organization — each monitored repo gets its own independent proofs.
- Choose the source and target. The App reads commit hashes from your source repository and writes proofs into a target repository, either a dedicated
timestampsbranch in the same repo or a separate shadow repo. - Confirm the permissions. Standard mode needs read-only access to the source repo, because GitHub’s permission model has no “commit hashes only” scope. Write access is needed on the target repo so proofs can be committed back. That’s the whole permission surface.
Nothing gets installed on developer machines. No CLI tools, no pre-commit hooks, no key files to distribute, no onboarding step for new hires. Developers keep running git commit and git push exactly as before.
For organizations that don’t want the hosted service to have read access to source code at all, there’s Enterprise ZK mode: a short GitHub Action (12 lines) runs inside your own infrastructure and sends only the commit hash to the API, so source code never leaves your environment. Under this mode, the App needs no read access to the source repo — you just install the Action. Most teams start with standard managed mode and treat ZK mode as an option for their most sensitive repositories. The full permission walkthrough lives in Set Up IP Protection With a Single GitHub App Install.
Inside the Automated Pipeline: From Commit to Bitcoin Anchor
Once installed, the pipeline runs on its own schedule. Here’s what happens between your git push and a verifiable proof:
- Commit detection. The GitHub App picks up new commits via webhooks. In Enterprise ZK mode, your GitHub Action pushes commit hashes to the API instead.
- Hash queue. Commit hashes land in an in-memory key-value store, waiting for the nightly batch. Note what arrives here: hashes, not code.
- Midnight cron worker. A worker wakes up, groups every pending hash, and writes one manifest
.txtfile per repository. - Merkle tree construction. The worker builds a Merkle tree natively over that day’s batch, then generates OpenTimestamps proofs against public OTS calendars.
- Bitcoin anchoring. The Merkle root is anchored into a Bitcoin block. Confirmation typically takes around three hours, so proof delivery follows a few hours after the batch runs.
- Proof delivery. The manifest and
.otsreceipt files are committed back to your target repository automatically.
Two properties of this design matter more than the mechanics:
- Zero-knowledge by construction. The service never sees, copies, or stores your source code. It handles commit hashes and a Merkle root. Your repository state never enters the pipeline.
- Vendor independence. The proofs rest on SHA-256 and Bitcoin block data alone. If Timestamp GIT disappeared tomorrow, the receipts in your repo remain checkable against the Bitcoin blockchain using standard OpenTimestamps tooling. For day-to-day work you’ll use the verification page or API instead — see How to Verify a Bitcoin Timestamp Proof for Your Code.
Monitoring and Failure Handling: Ensuring Every Commit Gets Anchored
Automation you don’t monitor is just a hopeful cron job. Timestamp GIT exposes enough surface area to make coverage observable.
Status dashboard. Each monitored repo has a public status page at https://timestampgit.dev/status/{user}/{repo} showing proof longevity, earliest anchor date, daily regularity, the Bitcoin block and transaction data, a calendar heatmap of anchored days, and downloadable audit exports.
Embeddable badges. Shields.io badges can go straight into your README, with markdown snippets generated right after you connect the repository. Anyone can click through to verify the timestamp publicly.
API for custom alerting. Poll status and reconcile counts from your own tooling:
# Latest anchored Bitcoin block for a repo
curl -s https://timestampgit.dev/api/statusLast/acme/payments-api | jq
# Total committed / stamped commit count
curl -s https://timestampgit.dev/api/statusCount/acme/payments-api | jq
# Combined summary (what the badge uses)
curl -s https://timestampgit.dev/api/statusSummary/acme/payments-api | jq
A minimal nightly check that flags a gap before it becomes an evidence problem:
import datetime, requests
REPO = "https://timestampgit.dev/api"
USER, SLUG = "acme", "payments-api"
summary = requests.get(f"{REPO}/statusSummary/{USER}/{SLUG}", timeout=30).json()
last = requests.get(f"{REPO}/statusLast/{USER}/{SLUG}", timeout=30).json()
# Alert if nothing has been anchored in the last 48 hours
print("summary:", summary)
print("last anchor:", last)
Point that at your alerting channel and you’ve closed the loop — a missed day becomes a notification instead of a discovery during due diligence.
Failure scenarios. Webhooks get dropped, calendars occasionally go down, and networks hiccup. Because hashes sit in a queue rather than being stamped inline, an unanchored hash simply rolls into the next nightly batch. Nothing is lost; it’s deferred. The visible symptom is a missing day on the heatmap or a stalled statusLast value, which is exactly what the checks above catch.
Compliance exports. For audits, pull the full ledger as CSV or a per-day PDF certificate:
curl -sO https://timestampgit.dev/api/audit/acme/payments-api
curl -sO https://timestampgit.dev/api/report/acme/payments-api/2026-11-22
Private repositories append an encrypted HMAC to their status URLs, so only authorized users can read their status — the HMAC is specific to the server instance.
Best Practices for Automated Timestamping
- Watch the timestamps branch, not just the dashboard. New manifests and
.otsfiles appearing is your ground truth that delivery worked end to end. - Use a dedicated target repository for proofs when you can. It keeps your source history clean and makes the evidence easy to hand to counsel without exporting your codebase.
- Verify periodically, not just once. Schedule a quarterly check against the public verification page or
/api/verify/{user}/{repo}/{date}. All verification computation happens locally in the browser — nobody sees what you verify. - Anchor coverage in your process, not your memory. If a repo is business-critical, install the App org-wide rather than repo-by-repo; the failure mode of selective installation is a repository nobody remembers to onboard.
- Match the deployment to your threat model. For air-gapped or maximum-security environments, Timestamp GIT runs as a self-hosted 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 instance is available at http://localhost:8080, and a first-launch wizard walks you through connecting your GitHub App. A time-limited demo license is available via the request form on the Docker License page (name, company, email, optional phone).
FAQ
Do I need to install any software on my developers’ machines? No. Timestamp GIT works entirely via a GitHub App or a GitHub Action. Developers just commit as usual; the automation handles the rest.
What happens if a commit is made after the nightly cutoff? It will be included in the next night’s batch. The system queues all pending hashes and anchors them together.
Can I automate timestamping for multiple repositories? Yes. You can install the GitHub App on multiple repositories or an entire organization, and each repo gets its own proofs.
How do I verify that a commit was timestamped? You can use the public verification page or API to check the Merkle proof against the Bitcoin blockchain. Badges also show status.
What happens if I push multiple commits in a day? All of them are collected into the day’s batch, folded into a single Merkle tree, and anchored together under one Bitcoin transaction. You still get per-repo manifests, so individual commit hashes remain traceable within the batch.
Can I timestamp commits from private repositories? Yes — private repositories are supported on the Pro Agency plan ($49/mo) and on Enterprise ZK ($199/mo, GitHub Actions). Public repositories are free on the Open Source tier.
How long does it take for a commit to be anchored? Typically a few hours after the nightly batch runs. Bitcoin confirmation itself normally takes around three hours, so proofs land in your repository a few hours after midnight.
Is the proof verifiable without Timestamp GIT? Yes. Proofs rely only on SHA-256 and Bitcoin block data, so they can be checked independently against the blockchain — no proprietary technology and no lock-in.
Conclusion
The value of prior-art proof comes from coverage, and coverage comes from automation. A timestamping process that depends on a person remembering to run something will have holes in it, and holes are what opposing counsel looks for.
Timestamp GIT handles the OpenTimestamps protocol for you: install the GitHub App once, let the nightly cron anchor every commit into Bitcoin, watch the badges and status endpoints, and keep the .ots receipts in a repo you control. Setup takes minutes; after that, the only ongoing task is glancing at an alert that should never fire.
Start with the free Open Source tier on a public repository, or connect a private one on Pro Agency and let the first batch run tonight. For a broader look at what this costs versus rolling your own, read Code Timestamping Costs Compared: Managed vs DIY.
Related posts
- Code Timestamping Costs Compared: Managed vs DIY
- Set Up IP Protection With a Single GitHub App Install
- How to Verify a Bitcoin Timestamp Proof for Your Code