How to Timestamp Git Commits Without the Command Line
You want the property, not the procedure. The property is: this commit hash existed on this date, and here is a receipt that anyone can verify against the Bitcoin blockchain. The procedure you want to skip is installing tooling on every developer laptop, chasing proof files through chat threads, and hoping someone remembers how the verification side works two years later, when a lawyer asks.
This guide shows how to timestamp Git commits without command line tools. Everything below happens in a browser and in GitHub. You’ll install a GitHub App once, point it at a repository, and then keep committing exactly as you do today. Timestamp GIT batches the commit hashes each night, anchors them into Bitcoin via the OpenTimestamps protocol, and pushes the proof receipts back into your repository.
No CLI. No local Bitcoin node. No protocol knowledge required.
Why Skip the Command Line for Git Timestamping?
The hard way exists, and you can probably guess its shape: install the OpenTimestamps client on your machine, run a command against a file you constructed, keep the resulting receipt somewhere, and repeat it whenever you remember to. Three failure modes follow immediately:
- It’s per-machine. Onboarding a new developer means re-explaining the ritual. Your CI runner needs it too. Your laptop replacement needs it again.
- It’s per-moment. Timestamps only cover what you remembered to stamp. The commits you forgot — usually the interesting ones, made during a crunch — are the ones you’ll want in a dispute.
- It’s fragile evidence. A receipt sitting in someone’s home directory with no chain of custody is not an audit trail.
The managed way moves all of this server-side. Timestamp GIT is a GitHub App that watches your repositories and anchors commit hashes automatically every night. You never touch the underlying protocol. The proof is written back into your own repository, in a dedicated branch or a shadow repo, so it lives with the code it describes.
For background on why a plain git log isn’t evidence in the first place, see Why Your Git Log Isn’t Proof. This article is the how-to.
Prerequisites
Before you start, confirm you have:
- A GitHub account and a repository — public or private — that you want to timestamp.
- Admin permissions on that repository or on the organization that owns it, so you can install a GitHub App.
- For private repositories, a paid plan: Pro Agency ($49/mo) or Enterprise ZK ($199/mo). Public repositories are free under the Open Source plan.
- Nothing else. No local software, no OpenTimestamps installation, no Bitcoin node, no wallet. A browser is the entire toolchain.
One note on permissions, because it’s the question people ask first. The GitHub permission model has no “commit hash only” scope, so Standard Mode requires read-only access to the source repository and read-write access to the target repository where proofs are written. If even read-only access to source is unacceptable to you, Enterprise ZK Mode uses a GitHub Action instead and requires no read access to source at all. More on that in Step 6.
Step-by-Step: Timestamp Commits Without the Command Line
Step 1: Install the Timestamp GIT GitHub App
Install the app from the GitHub Marketplace or from timestampgit.dev. During installation you’ll be asked which repositories the app can see, and you’ll grant the two permission sets described above: read-only on your source repo, read-write on the repo that will receive proof files.
If you’re stamping a whole organization, install at the org level once rather than repo by repo.
Step 2: Select Repositories to Monitor
Open the dashboard at https://timestampgit.dev/repos and choose which repositories are monitored. Once a repository is connected, the app detects new commits through GitHub webhooks — nothing to configure per commit, and nothing to remember.
You can sanity-check the connection immediately. The public status endpoints return JSON, no CLI needed:
# Last anchored Bitcoin block for a repo
curl -s https://timestampgit.dev/api/statusLast/your-user/your-repo
# How many commits have been stamped so far
curl -s https://timestampgit.dev/api/statusCount/your-user/your-repo
A brand-new repository will legitimately return zero counts until the first nightly run completes.
Step 3: Commit As Usual
This is the whole “workflow change” step, and it is empty. You write code, you git commit, you push. Timestamp GIT captures the commit hash the webhook delivers — not the diff, not the files, not the source. The service never sees, copies, or stores your actual code; only the SHA that identifies the repository state.
Practically, that means your developers don’t need training, and your security review has a short answer: the only data leaving the repo is a hash, and a hash is a one-way fingerprint.
Step 4: Let the Nightly Cron Do the Anchoring
At midnight, a worker collects every pending commit hash, groups them by repository, and writes one manifest text file per repo. It builds a Merkle tree over the batch, creates OpenTimestamps proofs against public OTS calendars, and anchors the Merkle root into a Bitcoin transaction.
Two things follow from that design:
- Batching is cheap and private. Individually anchoring thousands of commits would be absurd. One Merkle root per repository per day means one anchor covers everything committed that day, and the individual hashes stay hidden inside the tree.
- Proof delivery is not instant. The manifest and
.otsreceipt files are pushed back to a dedicated timestamps branch or shadow repository after Bitcoin confirmation, which normally takes around three hours. A run that starts at midnight typically finishes in the early morning.
Commit hashes wait in an in-memory key-value store until the run, so a repository that goes quiet for a day simply produces no new proof file — not an error.
Step 5: Embed a Verification Badge (Optional)
Open the Repository Connected page for your repo — https://timestampgit.dev/connected/{user}/{repo} — and use the badge widget. It renders a live preview and gives you a Markdown snippet to paste into your README, so the provenance claim is public and clickable rather than a paragraph of assertion.
<!-- Paste the exact snippet generated by the badge widget -->
[](https://timestampgit.dev/status/your-user/your-repo)
Anyone who clicks the badge lands on the public status page, which is also where auditors will want to go.
Step 6: Self-Host or Go Zero-Knowledge (Optional)
Two alternative deployments exist for teams with stricter requirements.
Enterprise ZK Mode flips the data flow: a 12-line GitHub Action runs on your own infrastructure and pushes only the commit hash to the Timestamp GIT API. Your source never leaves your environment, and no read access to the source repository is needed — only read-write on the target repo for proof delivery.
Docker self-hosted is for air-gapped environments and anyone who wants the instance inside their own perimeter. 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. On first launch, a setup wizard walks you through connecting your GitHub App and configuring the instance. Self-hosting requires a license: you can request a time-limited demo license from the Docker License page with your name, company, email, and optional phone number, and download the license file for evaluation.
How to Confirm It Worked
Don’t take the badge as proof. Confirm at three levels, in increasing order of rigor.
1. The repository status page. Visit https://timestampgit.dev/status/{user}/{repo}. You’ll see proof longevity, the earliest anchored date, daily regularity, the Bitcoin block and transaction data behind each anchor, and a calendar heatmap showing which days produced proofs. The heatmap is the fastest way to spot gaps.
2. The audit artifacts. From the status page or the API, pull the audit ledger or a per-date certificate:
# Full audit ledger as CSV
curl -s -o audit.csv https://timestampgit.dev/api/audit/your-user/your-repo
# PDF certificate for a specific date
curl -s -o certificate.pdf https://timestampgit.dev/api/report/your-user/your-repo/2026-11-03
These are the documents you hand to a lawyer or an auditor, and the CSV is what a compliance team will actually diff against internal records.
3. Local cryptographic verification. The verification page at https://timestampgit.dev/verification/{user}/{repo}/{date} walks the Merkle chain step by step, and all computation happens locally in your browser. Nothing about what you verify is transmitted. The same day’s .ots receipt file sits in your timestamps branch, and anyone can independently check it against the Bitcoin blockchain with standard OpenTimestamps tools — no account, no API key, no dependency on Timestamp GIT existing.
That last point is the one worth repeating to legal: the proof is SHA-256 plus Bitcoin block data. There’s no proprietary format in the trust path.
Troubleshooting Common Issues
Proofs haven’t appeared yet. Check the clock before checking anything else. Anchoring requires a Bitcoin confirmation, which normally takes about three hours after the midnight batch. If it’s 2 a.m., nothing is wrong. If it’s the next afternoon and the branch is still empty, look at whether the repository is actually in the monitored list.
Commits are missing from the manifest. Almost always a permissions or webhook problem. Confirm the GitHub App installation includes the specific repository (org installs commonly grant “selected repositories” and then miss one), and that the app still has an active connection. Re-check /api/statusCount/{user}/{repo} after the next nightly run.
A private repo’s status page won’t load. Private repositories append an encrypted HMAC to the URL, and that HMAC is specific to the server instance. Copy the authenticated badge link from the Repository Connected page instead of hand-constructing a URL — a truncated or instance-mismatched HMAC will fail.
The Docker deploy won’t come up. Verify the Compose file names rue1401/timestampgit:prod and valkey/valkey:8 exactly, that port 8080 isn’t already bound, and that ./data exists and is writable by the container. docker compose logs -f timestampgit will normally name the failing dependency outright. If the app starts but the setup wizard can’t reach GitHub, the OAuth configuration is the place to look.
FAQ
Do I need to install anything on developer machines? No. Timestamp GIT is a managed GitHub App that runs on GitHub’s infrastructure and our servers. Developers just commit as usual; no CLI tools or local software are required.
Can I timestamp commits in private repositories? Yes. Private repositories are supported on paid plans (Pro Agency or Enterprise ZK). The app reads only commit hashes, never your source code, and proofs are stored in a dedicated branch or shadow repository.
How long does it take for a timestamp to become immutable? After the nightly batch, the Merkle root is anchored into a Bitcoin transaction. Confirmation typically takes around 3 hours, after which the timestamp is immutable and verifiable.
Is the proof vendor-independent? Yes. The proof uses only SHA-256 and Bitcoin block data via the OpenTimestamps protocol. You can verify it offline with standard OpenTimestamps tools, even if Timestamp GIT ceases to exist.
What does the compliance team actually get?
A public status page, a downloadable audit CSV covering the repository’s history, a PDF certificate per date, and .ots receipts in-repo. For the legal weight of that evidence, see Is a Blockchain Timestamp Legally Valid Evidence?.
Conclusion: Install Once, Prove Forever
Timestamping Git commits without the command line comes down to one decision: stop treating timestamping as a per-developer ritual and make it a property of the repository. Install the GitHub App, select the repos, keep committing. The nightly cron turns those commits into Merkle-rooted proofs anchored in Bitcoin, and the receipts land back in your own repository where they belong.
Start with the free Open Source plan on a public repo — it costs nothing and takes about five minutes. When you’re ready to cover private code, move to Pro Agency at $49/mo, or go Enterprise ZK at $199/mo if the GitHub Action model fits your security posture better. Either way: timestampgit.dev is the only install step.
Related posts
- Timestamp GIT Alternatives: What to Compare First
- Git Commit Timestamps Aren’t Tamper-Proof — What Is
- Best Code Timestamping Tools in 2026