Automated Git Timestamping: Anchor Commits to Bitcoin
If your prior-art protection depends on someone remembering to run a tool after every commit, you don’t have prior-art protection — you have a habit. And habits break the week before an audit, during a release crunch, or right after the person who “always did that” changes teams.
Manual timestamping has a predictable failure loop. You commit, then you remember to stamp. You copy the receipt somewhere it won’t get lost. You do it again tomorrow, and the day after, for every repository that matters — and the moment you’re on a branch-heavy sprint, the loop silently stops. One repository scales. Five repositories with three contributors each do not.
This article is about eliminating that loop entirely: automated Git timestamping on Bitcoin, where the only recurring action is a commit you were already going to make.
You can do this the hard way by running the OpenTimestamps tooling yourself and babysitting receipt files. Timestamp GIT exists so you don’t have to. It’s a managed service that hides the protocol entirely: install the GitHub App once, and every commit to a monitored repository is anchored into Bitcoin automatically each night. No CLI tools, no protocol commands, no daily checklist. For the install walkthrough itself, see GitHub App Blockchain Timestamp Setup: Install Once, Timestamp Forever — this article focuses on what happens after the install.
The Repetitive Manual Task You Can Eliminate
Before settling on automation, it’s worth naming exactly what’s being removed from your week:
- A per-commit ritual. Something has to run after every commit that deserves proof. That’s a human in the loop, on every commit, forever.
- Receipt sprawl. Proof files end up in a personal folder, a shared drive, or a Slack thread. Six months later nobody can map a receipt to a date or a repository.
- Coverage decay. You protect the flagship repo. The internal tooling repo, the client library, the trade-secret service — nobody stamps those, and those are frequently the ones that matter in a dispute.
- Silent gaps. Missing a single day is invisible until you need the proof, which is the worst possible time to discover a hole in your timeline.
“What automated” means here is narrow and specific. You install the GitHub App once on the repositories you want monitored. From then on, every commit is detected, batched, and anchored into the Bitcoin blockchain each night with no developer action. Developers keep committing exactly as they do today. There is nothing to install on their machines, no pre-commit hook, no new workflow to learn.
That’s the difference between a process and a background property of your repositories.
One-Time Setup: Install the GitHub App and Forget It
Timestamp GIT gives you two ways to connect a repository, both of which are one-time configuration.
Standard Mode (GitHub App). Install the GitHub App on the repositories you want monitored. It reads only the HEAD commit hash of each monitored repository automatically. Proofs are written into a dedicated Git branch — either in the same repository as the source or in a separate one.
The permission model is worth understanding plainly, because it’s less than people expect:
- Read-only access to the source repository. The GitHub permission system has no “commit-hash-only” scope, so read-only is the minimum the App can request to see the HEAD hash.
- Read-write access to the target repository, which is where the manifest and receipt files get pushed.
Enterprise ZK Mode. A 12-line GitHub Action runs on your own infrastructure and pushes only the commit hash to the Timestamp GIT API. That configuration requires read-write access to the target repository only — no read access to the source repository is needed, and your source never leaves your environment.
Whichever mode you choose, the developer experience is identical for your team: nothing to install on developer machines, no changes to how anyone branches, commits, or merges.
If you need to self-host. For maximum security or air-gapped environments, Timestamp GIT is also available as a 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 application is available at http://localhost:8080 after startup, and a setup wizard guides you through connecting your GitHub App and configuring your instance on first launch. Licensing, the demo license request form, and the full self-hosted walkthrough live in Self-Hosted Git Timestamps: Docker Setup & License Guide.
The Automated Pipeline: From Commit to Bitcoin Anchor
Once connected, the pipeline runs without you. Here’s the actual sequence.
1. Commit detection. Either the GitHub App detects new commits via webhooks, or — in Enterprise ZK Mode — your GitHub Action pushes commit hashes to the API.
2. Hash queue. Commit hashes land in an in-memory key-value store for batching. Nothing else is stored, because nothing else was sent.
3. The midnight cron worker. Each night, a worker:
- Groups all pending hashes
- Creates per-repo manifest files (
.txt) - Builds a Merkle tree natively
- Creates OpenTimestamps proofs using public OTS calendars
- Anchors the Merkle root into the Bitcoin blockchain
4. Proof delivery. The manifest and .ots receipt files are pushed back to your repository in a dedicated timestamps branch or shadow repository.
The whole flow looks like this:
commit ──▶ hash queue ──▶ midnight cron ──▶ Merkle root ──▶ Bitcoin block
│
└──▶ manifest.txt + .ots receipt
│
▼
timestamps branch / shadow repo
In Enterprise ZK Mode, your GitHub Action talks to the ZK Commit API, which is authenticated with an HMAC from the signed URL the API returns for your repository:
# The signed URL (and its HMAC) is returned by the API for your repo.
# {target} is the destination repo, {hash} is the HMAC from that URL.
curl -X POST \
"https://timestampgit.dev/api/timestamp/acme/payments-api/timestamps/<hmac>/<commitHash>/<commitId>"
Timing expectation. Bitcoin confirmation takes several hours — normally around 3 — so proof writing completes a few hours after the nightly run, not at midnight sharp. If you check your timestamps branch at 00:05 and see nothing, that’s expected behavior, not a failure.
Monitoring and Failure Handling
Automation you can’t observe is indistinguishable from automation that stopped working. Timestamp GIT exposes public status endpoints so you can watch the pipeline without logging in:
# Last anchored Bitcoin block
curl -s https://timestampgit.dev/api/statusLast/acme/payments-api
# Total committed / stamped commit count
curl -s https://timestampgit.dev/api/statusCount/acme/payments-api
# Combined summary (Shields.io friendly)
curl -s https://timestampgit.dev/api/statusSummary/acme/payments-api
Badges. Embeddable verification badges are available for your README, so anchor status is visible to anyone browsing the repository. Anyone can follow the badge link to verify the timestamp — there’s a dedicated viewer and a PDF report. Private repositories are supported too: their status URLs append an encrypted HMAC specific to the server instance, so only authorized users can see the status.
Repository Status dashboard. At /status/{user}/{repo} you get proof longevity, earliest anchor date, daily regularity, Bitcoin block and transaction data, and a calendar heatmap — the fastest way to spot a gap in coverage visually.
Audit and reporting endpoints. When you need evidence rather than a dashboard:
# Full audit ledger as CSV
curl -sO https://timestampgit.dev/api/audit/acme/payments-api
# PDF certificate for one specific date
curl -sO https://timestampgit.dev/api/report/acme/payments-api/2026-10-21
When a night looks missing, work through it in this order:
- Check
statusLastandstatusCount. If the last anchor is several hours older than expected, confirmation may simply still be in progress. - Confirm the GitHub App still has repository access. An uninstalled App, a revoked permission, or a renamed repository will silently stop detection.
- In Enterprise ZK Mode, check the Action’s run history on your side — the push to the API is the only link that can break locally.
- Re-check after Bitcoin confirmation completes before assuming anything is lost.
Best Practices for Automated Timestamping
- Monitor every repository that matters, not just the flagship. Coverage is the entire value of the automation; a single protected repo still leaves the rest of your work exposed.
- Keep commits meaningful. Automation timestamps what you commit, so commit hygiene still shapes the story your anchored history tells. A hundred “wip” commits prove less than a clean, descriptive history.
- Put the badge in the README and keep the audit CSV and per-date PDF reports with your IP records. Those artifacts are what you hand to an auditor or opposing counsel.
- Verify independently when it counts. Download the
.otsfile and check it with standard OpenTimestamps tools against Bitcoin. The proof is vendor-independent by design — it uses only SHA-256 and Bitcoin block data. The step-by-step walkthrough is in How to Verify a Bitcoin Timestamp Proof Locally. - Remember the zero-knowledge guarantee. Only commit hashes are stamped, never source code, so automating across every repository doesn’t widen your exposure at all — it’s the same hash whether you have one repo or fifty.
FAQ
Does automated Git timestamping ever read or store my source code?
No. Timestamp GIT only processes commit hashes. In Standard Mode the GitHub App reads the HEAD commit hash, and in Enterprise ZK Mode a GitHub Action on your infrastructure pushes only the hash to the API. Your source code never leaves your environment in ZK mode and is never copied or stored by the service.
How long after I commit does the Bitcoin anchor get confirmed?
Commits are batched and anchored by a nightly cron worker. Bitcoin confirmation takes several hours, normally around 3 hours, so the .ots receipt and manifest files appear in your timestamps branch or shadow repository a few hours after the nightly run.
What happens to my proofs if Timestamp GIT shuts down?
The proofs remain valid. They rely only on SHA-256 and Bitcoin block data via the OpenTimestamps protocol, so anyone can download the .ots file and verify it independently against the Bitcoin blockchain using standard OpenTimestamps tools — no proprietary technology, no lock-in.
Can I use automated timestamping with private repositories?
Yes. Private repositories are supported, and status URLs append an encrypted HMAC specific to the server instance so only authorized users can view the status. Public verification badges and the status dashboard work the same way once access is granted.
Conclusion: Set It Once, Prove It Forever
The shift here is small in effort and large in consequence. You stop maintaining a daily chore and start owning a property of your repositories: every commit, anchored into Bitcoin, automatically, every night, with a receipt you can hand to a lawyer, an auditor, or a court. The proof is embedded in Bitcoin, court-ready, and verifiable by anyone without proprietary tools — and it’s all driven by Timestamp GIT on the backend, not by your developers.
If your team can’t use a managed service at all, the Docker self-hosted option covers maximum-security and air-gapped environments with the Compose setup shown above.
Install the GitHub App on your first repository today and let the pipeline run tonight. Tomorrow, check statusLast — you’ll have an anchor you’d otherwise have spent a year trying to remember to create.
Related posts
- How to Prove Code Ownership in a Client Payment Dispute
- OpenTimestamps Alternative: Managed GitHub App for Every Commit
- Self-Hosted Git Timestamps: Docker Setup & License Guide