Timestamp GIT

← All posts

2026-11-06

OpenTimestamps Without the CLI: Managed Bitcoin Timestamping

OpenTimestamps Without the CLI: Managed Bitcoin Timestamping
timestamp git blockchain proof

OpenTimestamps Without the CLI: Managed Bitcoin Timestamping

If you have ever looked into proving that a piece of code existed on a specific date, you have probably run into OpenTimestamps. You have also probably run into the part nobody puts in the headline: the command line, the calendars, the .ots files, and a vague sense that you now need to understand Bitcoin transactions.

This article is OpenTimestamps explained without the CLI. Not because the protocol is bad — it is genuinely excellent — but because the command line is an implementation detail, not a requirement. There is a managed path where a GitHub App watches your repository and anchors every commit into Bitcoin while you sleep. You install it once. You never type a timestamping command.

We will cover what OpenTimestamps actually does, why a notary analogy fits almost perfectly, what happens under the hood each night, and the misconceptions that stop teams from adopting it. Raw protocol mechanics are treated as background here; the focus is the automated workflow and what it gives you.

What Is OpenTimestamps Without the CLI?

OpenTimestamps is a protocol for proving that some data existed at or before a certain point in time. It does this by aggregating data into a Merkle tree, hashing the root, and committing that root into a Bitcoin block. Because Bitcoin blocks are immutable and globally replicated, the anchor becomes a public, tamper-evident record of existence.

The CLI is just one interface to that protocol. A web service, a GitHub App, or a scheduled worker can do exactly the same thing — and do it better, because batching and calendar handling are the parts humans are bad at.

The managed approach looks like this: you install the Timestamp GIT GitHub App on a repository. From that point on, every commit is detected automatically, batched nightly, and anchored into Bitcoin via OpenTimestamps. Proofs land back in your repository as receipt files and manifests. No commands, no local tooling, no Bitcoin node.

To be explicit about scope: this article explains the concept and the managed workflow. It does not walk you through raw protocol operations. If you want the deeper dives on adjacent topics, see how to verify a Bitcoin timestamp proof in your browser and why your Git log isn’t proof.

A Simple Analogy: The Notary Public for Your Code

Imagine a notary public. You hand them a document. They do not read it. They compute a tamper-evident seal over it, stamp it with a date, and record that seal in a public ledger anyone can inspect. Later, if someone challenges the date, you produce the document, recompute the seal, and point at the ledger entry.

OpenTimestamps is that notary, with two upgrades:

  • The “document” is a hash, not your code. Git already produces a unique one-way hash (SHA-1 or SHA-256) for each commit, representing the exact state of your repository at that moment. That hash is the fingerprint. Timestamp GIT only ever handles the fingerprint.
  • The ledger is the Bitcoin blockchain. Instead of a notary’s bound book in a filing cabinet, the seal is recorded in a block that thousands of independent nodes replicate. Nobody — not you, not us, not a court order — can rewrite it.

The third upgrade is the one that matters day to day: with Timestamp GIT, the notary visits you automatically every night. No appointment, no queue, no paperwork. You commit code; the stamping happens on a schedule you never think about.

How It Works Under the Hood (Briefly)

Three steps, and only the middle one involves anything resembling infrastructure.

Step 1 — The fingerprint. When you commit, Git generates a unique hash for that commit. Timestamp GIT collects only these hashes. Your source code is never read, copied, or stored.

Step 2 — The anchor. A midnight cron worker groups all pending hashes, builds a native Merkle tree per repository, creates a manifest .txt file, and anchors the Merkle root into Bitcoin using public OpenTimestamps calendars.

Step 3 — The proof. The manifest and .ots receipt files are pushed back into your repository — in a dedicated timestamps branch or a separate shadow repository. From there, anyone can verify offline against Bitcoin block data.

Two operational details worth knowing:

  • Bitcoin confirmation takes several hours, normally around three. Proof writing therefore completes a few hours after the nightly batch, not instantly.
  • Verification is vendor-independent. The proof relies only on SHA-256 and Bitcoin block data. No proprietary format, no lock-in.

Here is the shape of what a nightly batch produces, conceptually:

timestamps/
├── 2026-11-05/
│   ├── manifest.txt        # commit hashes for the day
│   └── manifest.txt.ots    # OpenTimestamps receipt for the Merkle root
└── 2026-11-06/
    ├── manifest.txt
    └── manifest.txt.ots

The receipts are the artifact you keep. Everything else is convenience.

Why Managed Timestamping Matters

Running the protocol yourself is possible. It is also a maintenance project: calendar reliability, batching logic, Bitcoin confirmation handling, storage of receipts, and a verification story for auditors. For most teams, that is a distraction from the actual product.

A managed service removes those moving parts:

  • No protocol knowledge required. You do not need to learn calendar servers, Merkle proofs, or Bitcoin transaction structure. The hard way exists; you are allowed to skip it.
  • Court-ready, vendor-independent proofs. The evidence lives in Bitcoin, not in our database. Anyone can check it without trusting us.
  • Workflow fit. Install the GitHub App once. Every subsequent commit is anchored automatically. No habits to change, nothing to install on developer machines.
  • Compliance surface. Public verification badges for README files, downloadable audit CSVs, and PDF certificates per date give auditors something concrete to look at.

For agencies and freelancers, that last point does real work during payment disputes and authorship claims. For companies, it is a shield against patent trolls asserting rights over things already running in internal systems.

Common Misconceptions About OpenTimestamps

“You need to be a Bitcoin expert.” You need to trust math, not expertise. With a managed service, the complexity is handled: batching, anchoring, and proof delivery happen on a schedule. You interact with a dashboard and a branch in your repo.

“Timestamping exposes my source code.” It does not. Only commit hashes are anchored. The service never sees, copies, or stores your code — the zero-knowledge principle is architectural, not a policy promise. In Enterprise ZK mode the hash submission runs as a GitHub Action on your own infrastructure, pushing only the hash to the API, so the service has no read access to the source repository at all.

“Proofs are only as reliable as the vendor.” The proofs are Bitcoin-native. You can download the .ots receipt files and verify them offline using standard OpenTimestamps verification against the blockchain. If Timestamp GIT disappeared tomorrow, your proofs would still be valid.

“It’s expensive and slow.” Daily batching means many commits share one Bitcoin anchor, which is why the economics work. Confirmation takes a few hours — acceptable for prior-art evidence, which is judged in months and years, not minutes.

Getting Started Without the CLI

There are two deployment modes, and neither requires a terminal on developer machines.

Standard Mode (GitHub App). Install the GitHub App on the repositories you want monitored. It reads the HEAD commit hash automatically and writes proofs into a dedicated branch — either in the same repository or a separate target repository. GitHub’s permission model requires at least read-only access to the source repo (there is no commit-hash-only permission), plus read-write access to the target repo.

Enterprise ZK Mode. A 12-line GitHub Action runs on your infrastructure and pushes only the commit hash to the Timestamp GIT API. Here you need read-write access only to the target repository, and no read access to the source. Choose this when even hash visibility must stay inside your perimeter.

Either way, the sequence after installation is uneventful: commits are detected, hashes are queued, the nightly worker anchors them, and proofs appear in your timestamps branch a few hours after Bitcoin confirmation.

Self-Hosting With Docker

For air-gapped or maximum-security environments, Timestamp GIT ships 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

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 walks you through connecting your GitHub App and configuring the instance. A time-limited demo license for evaluation can be requested from the Docker License page with your name, company, email, and optional phone number; the license file is downloadable immediately.

What You Get Once It’s Running

  • A public status dashboard per repository: proof longevity, earliest anchor date, daily regularity, Bitcoin block and transaction data, a calendar heatmap, and downloadable audit CSV and PDF certificate.
  • Verification badges for your README, with a link anyone can follow to check the timestamp. Private repositories append an encrypted HMAC to the URL so only authorized users can see status.
  • A browser-based verifier that performs the multi-level Merkle chain check locally, so nobody sees what you verify.
  • A REST API if you want to script status checks: /api/statusLast/{user}/{repo}, /api/statusCount/{user}/{repo}, /api/audit/{user}/{repo}, and friends.
# Check the last anchored Bitcoin block for a repo
curl https://timestampgit.dev/api/statusLast/youruser/yourrepo

Plans line up with how much privacy you need: Open Source for public repositories, Pro Agency for private repos, and Enterprise ZK for GitHub Action–based isolation. Details are on the pricing page.

FAQ

Do I need to install any software or run commands to use OpenTimestamps with Timestamp GIT?

No. Timestamp GIT is a managed GitHub App. You install it once, and it automatically timestamps your commits nightly. There are no CLI tools to install or commands to run.

How does Timestamp GIT ensure my source code remains private?

Timestamp GIT operates on a zero-knowledge principle: it only processes Git commit hashes, never your actual source code. In Enterprise ZK mode, even the hashes are pushed from your infrastructure via a GitHub Action, so the service never has read access to your repository.

Can I verify the timestamps independently without trusting Timestamp GIT?

Yes. The proofs are anchored in the Bitcoin blockchain using the OpenTimestamps protocol. You can download the .ots receipt files and verify them offline using standard OpenTimestamps verification, or use the built-in browser-based verifier that runs locally.

What happens if Timestamp GIT goes out of business?

Your proofs remain valid because they are embedded in the Bitcoin blockchain. Verification relies only on Bitcoin and SHA-256, so you can continue to prove your code’s existence independently.

Conclusion

OpenTimestamps solves a real problem — proving that data existed at a specific time — and it solves it with nothing but hashing and Bitcoin. The command line was never the point. It was just the first interface.

The managed interface is better suited to how teams actually work: install a GitHub App, keep committing, and let a nightly job anchor the hashes. You get .ots receipts, a manifest branch, verification badges, audit CSVs, and PDF certificates — all backed by proofs that survive the vendor.

If you want the automated version, install Timestamp GIT on a repository and commit something. That is the entire setup. The notary shows up tonight.

EU label: AI-generated content