Timestamp GIT

← All posts

2026-10-11

Automatic Nightly Git Commit Anchoring to Bitcoin, Zero Manual Steps

Automatic Nightly Git Commit Anchoring to Bitcoin, Zero Manual Steps
timestamp git blockchain proof

Automatic Nightly Git Commit Anchoring to Bitcoin, Zero Manual Steps

The most common way teams “timestamp” a commit is for a human to remember to do it.

Someone finishes a feature, remembers that the commit should be anchored, and runs the OpenTimestamps workflow by hand — the hard way — then saves the receipt somewhere. Two weeks later nobody remembers whether the receipt for that Tuesday exists. A different developer joins, doesn’t know the ritual, and six months of commits go unstamped.

That’s the manual timestamping trap: proof coverage that depends on memory. It works fine in a demo and falls apart across a team, a sprint cadence, and a year of turnover. Automatic nightly git commit anchoring to bitcoin flips the problem: the anchoring stops being a task a person performs and becomes a property of your repository. You install a GitHub App once, and every commit is batched and anchored while you sleep.

This article walks through that automated path end to end — setup, pipeline, monitoring, self-hosting — and is written for developers and compliance folks who care about the proof surviving an audit, not about babysitting a cron job.

The Manual Timestamping Trap (and How Automation Eliminates It)

Manually stamping commits has three failure modes, and all three are structural rather than personal:

  • Memory dependency. Someone has to remember to run the tooling at the right moment, ideally before the work is public. Late is the same as never for prior-art purposes.
  • Silent failures. When a manual run fails — network hiccup, expired calendar, wrong directory — nothing crashes. You simply have a gap in coverage that you discover a year later, during the dispute you needed the proof for.
  • Receipt sprawl. Receipts end up on laptops, in Slack threads, in a shared drive nobody owns. A proof you can’t find is a proof you don’t have.

None of this scales. A solo developer might keep the ritual alive for a few months. A team of ten will not, and an agency running client work across dozens of repos has no chance. Every missed night is a permanent hole in the record, because you cannot retroactively anchor a hash that was never captured.

Timestamp GIT is the zero-setup managed alternative: a GitHub App that captures commit hashes automatically, batches them, and anchors them into the Bitcoin blockchain via the OpenTimestamps protocol each night. No CLI tools, no manual receipts, nothing installed on developer machines. You get the cryptographic property — an immutable, independently verifiable date — without running the underlying protocol yourself.

Two deeper dives live elsewhere on this blog: How to Verify a Git Repository’s Bitcoin Timestamp covers the verification side, and Git Commit Timestamp Proof for Patent Disputes covers the legal framing. This article stays on the automation itself.

One-Time Setup: Install the GitHub App and Forget It

Setup is a single action, done once per repository or once per organization.

  1. Install the Timestamp GIT GitHub App on the repository (or on the whole organization, so new repos are covered by default).
  2. Pick the source repository that holds your code.
  3. Pick the target repository where proofs will be written — either the same repo on a dedicated branch, or a separate shadow repository.

That’s the entire configuration. There are no developer machine requirements: no daemon, no hook each engineer has to install, no onboarding checklist. New hires are covered on their first commit because coverage is a repository property, not a personal one.

The permission model. Standard Mode needs read-only access to the source repository plus read-write access to the target repository. The read-only requirement exists because GitHub’s permission system doesn’t offer a commit-hash-only scope — read access to the source is the minimum grant that lets the App see the HEAD commit hash. It only ever reads that hash.

If even a hash shouldn’t leave your environment, Enterprise ZK Mode replaces the App’s polling with a 12-line GitHub Action that runs on your own infrastructure and pushes nothing but the commit hash to the Timestamp GIT API. In that mode the service needs read-write access to the target repository only, and no read access to the source repository at all — you install the Action instead.

Either way, the guarantee is the same: we never see, copy, or store your actual source code. Only the hash is ever in play.

Inside the Automated Pipeline: From Commit to Bitcoin Anchor

Once installed, the pipeline runs without intervention. Here’s what happens between your git push and an immutable proof sitting in your repository.

1. Commit detection. In Standard Mode, the GitHub App detects new commits through webhooks. In Enterprise ZK Mode, your GitHub Action pushes the commit hash to the API. Either path produces the same artifact: a list of commit hashes.

2. Hash queue. Incoming hashes land in an in-memory key-value store used purely for batching. This is the waiting room — commits accumulate here until the next batch window.

3. Midnight cron worker. Each night, a worker takes every pending hash and:

  • groups them per repository,
  • writes a manifest file (.txt) for each repo,
  • builds a Merkle tree natively over the batch,
  • creates OpenTimestamps proofs using public OTS calendars,
  • anchors the Merkle root into the Bitcoin blockchain.

Batching is what makes this cheap and continuous. Whether you pushed one commit or four hundred that day, the cost and the cadence are the same.

4. Proof delivery. The manifest and .ots receipt files are pushed back into your repository — on a dedicated timestamps branch or into your shadow repository — automatically.

There’s one timing detail worth planning around: confirmation in the Bitcoin blockchain takes several hours, normally around three. So commits pushed today are queued tonight, anchored overnight, and the proof files appear a few hours later. You don’t wait on it; you just find them there the next morning.

The result, per day and per repo, is a tamper-evident chain: your commit hashes → manifest → Merkle tree → Merkle root → OpenTimestamps proof → Bitcoin block.

Monitoring and Failure Handling: Keeping the Chain Unbroken

Automation you don’t monitor is just a nicer-looking version of the manual trap. Timestamp GIT exposes public status endpoints so you can check the chain yourself, without a dashboard login:

# Last anchored Bitcoin block info for a repo
curl -s https://timestampgit.dev/api/statusLast/{user}/{repo}

# Total committed / stamped commit count
curl -s https://timestampgit.dev/api/statusCount/{user}/{repo}

# Combined summary, used for Shields.io badges
curl -s https://timestampgit.dev/api/statusSummary/{user}/{repo}

A simple continuity check that fits any scheduler: call statusLast once a day, store the raw response, and alert if it hasn’t changed since yesterday. If no new anchor landed, you’ve caught the gap the same week instead of the same decade.

If you’d rather not build that yourself, the public status dashboard at https://timestampgit.dev/status/{user}/{repo} does the work visually — proof longevity, earliest anchor date, daily regularity, the Bitcoin block and transaction data behind each anchor, and a calendar heatmap that makes missed nights immediately obvious. From the same page you can download the audit CSV and a PDF certificate.

Private repositories stay private. Status URLs for private repos carry an encrypted HMAC that is specific to the server instance, so only authorized users can read the status of those repositories. The proofs are still publicly verifiable in the Bitcoin sense — the hash is on-chain — but the surrounding metadata isn’t an open book.

Verification badges. For public repos, embeddable badges render your verification status directly in the README, with a link anyone can follow to verify the timestamp on the site. The badge makes the proof visible to a client, an acquirer, or opposing counsel without you having to produce anything.

When the App reconnects. If a repo is disconnected and reconnected, the connected page gives you the badge embed widget with a live preview so you can re-verify the linking is intact.

Best Practices for Reliable Nightly Anchoring

  • Put a human on the heatmap once a week. Nightly automation removes the daily task, not the accountability. A five-minute weekly glance at the status dashboard catches anything an alert might miss.
  • Alert on absence, not just errors. The dangerous state is silence. Alert when the anchor date stops advancing.
  • Use a dedicated timestamps branch or a shadow repository. Keeping proofs out of your default branch means no merge noise, no accidental interference with CI, and an audit trail that a reviewer can browse without cloning your application.
  • Embed badges where buyers look. In the README, near the license header. Public proof of existence is cheap credibility.
  • Export the audit ledger on a schedule. Pull the CSV regularly and archive it alongside your compliance materials, and generate a PDF certificate for each release milestone. Compliance teams want a document with a date on it; give them one before they ask.
  • Keep the “who can see what” story written down. Document your mode — Standard or Enterprise ZK — and the exact permissions granted. When procurement or legal asks, you’re answering a question you already answered.

Self-Hosting for Air-Gapped Environments: Docker Compose Quick Start

If your constraints rule out a managed service — regulated environments, air-gapped networks, strict data-residency rules — Timestamp GIT is available as a Docker image running the same automated pipeline on your own infrastructure.

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

Bring it up:

docker compose pull
docker compose up -d
docker compose logs -f timestampgit

The application is available at http://localhost:8080 after startup. On first launch, a setup wizard guides you through connecting your GitHub App and configuring your instance.

For evaluation, a time-limited demo license is available: submit the request form on the Docker License page with your name, company, email, and optional phone number, and you can download a demo license file to get started.

Self-hosting gives you maximum security and control with the same nightly batching and anchoring behavior — the Merkle tree, the OTS proofs, and the .ots files written back to your repositories.

FAQ

Do I need to run any commands or install tools on my machine? No. Timestamp GIT is a managed service: you install the GitHub App once, and every commit is automatically anchored each night. Nothing is installed on developer machines.

How long does it take for a commit to be anchored in Bitcoin? The nightly cron worker batches commits and anchors the Merkle root into Bitcoin via OpenTimestamps. Confirmation typically takes around 3 hours, after which the .ots proof files are pushed back to your repository.

Can I verify the timestamp independently? Yes. You can download the .ots file and use standard OpenTimestamps verification tools against the Bitcoin blockchain, or use the public verification page at https://timestampgit.dev/verification/{user}/{repo}/{date}, which runs every step of the multi-level Merkle chain check locally in your browser — nobody sees what you verify.

What if I need to keep my source code completely private? Use Enterprise ZK mode: a GitHub Action on your infrastructure pushes only the commit hash to the Timestamp GIT API, so your source never leaves your environment. Alternatively, self-host with Docker for full control.

The Anchor Is Only as Good as Its Regularity

A timestamp you made once proves one thing about one moment. A timestamp made every night, automatically, proves that a repository existed in a specific state on a continuous timeline — and that’s the version that holds up when someone challenges you eighteen months later. Manual stamping can’t produce that record, because the record is defined by the days you didn’t miss.

Timestamp GIT is built for exactly that: install the GitHub App on your repo or org, choose where proofs land, and let the nightly worker batch, Merkle-tree, and anchor your commit hashes into Bitcoin. Verify with a badge, a dashboard, or the .ots files themselves. If you’d rather run it inside your own network, the Docker self-hosted license has you covered.

Install it once. Then stop thinking about it.

Related posts

EU label: AI-generated content