Timestamp GIT

← All posts

2026-11-05

How to Verify a Bitcoin Timestamp Proof in Your Browser

How to Verify a Bitcoin Timestamp Proof in Your Browser
timestamp git blockchain proof

How to Verify a Bitcoin Timestamp Proof in Your Browser

A timestamp proof is only worth something the moment someone checks it. Until then it’s a file with a nice name — a .ots receipt sitting in a branch, a badge in a README, a PDF nobody opened. The question that decides whether your prior art survives a legal review, a payment dispute, or a due-diligence audit is a narrow one: can a third party confirm that this exact commit hash existed before a specific date, without asking the vendor to vouch for it?

That’s what browser-based verification solves. This article walks through verifying a Timestamp GIT proof end to end — what the artifacts contain, which pages and endpoints you use, and how to read the result when it’s valid, pending, or failing. It is not a lesson in Bitcoin transactions; the whole point of the managed workflow is that you never touch that layer.

Why Browser-Based Verification Matters

Verification is the moment a cryptographic timestamp stops being a claim and becomes evidence. Everything before it — hashing commits, batching manifests, anchoring a Merkle root in Bitcoin — is machinery. The proof either verifies at the other end or it doesn’t.

Two properties make the browser the right place for that check:

The computation stays local. Timestamp GIT’s verification pages perform every Merkle chain step in your browser. Nobody sees which repository, which date, or which commit you are checking. For a vendor this would be a strange design; for a zero-knowledge proof system it’s the only correct one. You are verifying evidence, not requesting a verdict.

No install, no trust fall. Compliance teams and outside counsel are not going to git clone a branch and compile tooling. They need an independent, repeatable check that produces the same answer every time. A URL plus a browser does that. So does a public API endpoint if you’d rather script the check in CI.

This matters because the alternative — trusting a vendor’s dashboard — is precisely the thing you’re trying to escape. See Git Commit Timestamps Aren’t Tamper-Proof — What Is for why internal logs get dismissed in audits in the first place.

What a Bitcoin Timestamp Proof Actually Contains

Before you verify anything, know what you’re holding. A Timestamp GIT proof for a given day consists of three layered artifacts:

  • Daily manifest — a plain .txt file listing the commit hashes that were anchored that day for a given repository. It contains hashes, never code.
  • .ots receipt — an OpenTimestamps proof that ties the manifest’s SHA-256 hash to a specific Bitcoin block.
  • Merkle chain — the structure connecting the two. Your individual commit hash is a leaf, the manifest is the next level up, and the Merkle root is the single value that gets embedded in Bitcoin.

So verification means climbing that chain in the right direction: take your commit hash, combine it with its siblings as specified by the manifest, produce the manifest hash, then check the .ots receipt against the Bitcoin block header.

The critical property is that the receipt is vendor-independent. It uses only SHA-256 and public Bitcoin block data. If Timestamp GIT disappeared tomorrow, the receipt would still verify against the blockchain using open tools. That’s not a marketing line — it’s a constraint on the proof format, and it’s why browser verification can be honest.

These files live in a dedicated timestamps branch (or a separate shadow repository), so they’re versioned alongside your code without ever exposing source contents.

Step-by-Step: Verify a Proof in Your Browser

Here’s the full path from “I have a repository” to “here is the artifact an auditor can keep.”

1. Start at the repository status page

Open the public status page for the repository:

https://timestampgit.dev/status/{user}/{repo}

This is your overview and it answers most first questions: proof longevity (how far back the chain goes), earliest anchor date, whether anchoring has been daily and regular, and the Bitcoin block and transaction data for each day. There’s a calendar heatmap so gaps are visible at a glance, plus downloads for the full audit ledger (CSV) and a PDF certificate.

If you only need a machine-readable summary, the public status endpoints return the same core numbers:

curl -s https://timestampgit.dev/api/statusLast/acme/payments-service
curl -s https://timestampgit.dev/api/statusCount/acme/payments-service
curl -s https://timestampgit.dev/api/statusSummary/acme/payments-service

2. Open the verification page for a specific date

For an actual proof check, go to the date you care about:

https://timestampgit.dev/verification/{user}/{repo}/{date}

The page walks you through each level of the Merkle chain step by step — commit hash to manifest, manifest to Merkle root, Merkle root to Bitcoin block. Every hash is recomputed in your browser. Nothing about your check is transmitted, which is what makes it usable for confidential repositories.

This is the page to send to a lawyer. It requires no account, no CLI, and no explanation of what OpenTimestamps is.

3. Use the badge as a public entry point

Embeddable badges are the low-friction version of the same thing. Add one to your README and anyone — auditor, acquirer, opposing counsel — can click through to verification without knowing your repository structure.

The badge embed widget at /connected/{user}/{repo} gives you a live preview plus the Markdown snippet. The badge itself is backed by the summary endpoint, so it reflects real anchored data rather than a static image.

Badges are a disclosure decision, not a security one: they expose that you timestamp, not what you wrote.

4. Verify programmatically with the public API

For CI pipelines or a compliance script, pull the Merkle chain data and verify locally:

curl -s "https://timestampgit.dev/api/verify/acme/payments-service/2026-10-14" \
  -o chain.json

The response contains the full chain for that day. Your script then recomputes the hashes itself — the same math the browser page runs:

// Node 18+ — recompute each Merkle step locally, never trust the server's answer
import { createHash } from "node:crypto";

const sha256 = (hex) =>
  createHash("sha256").update(Buffer.from(hex, "hex")).digest("hex");

const chain = JSON.parse(await readFile("chain.json", "utf8"));

// Walk leaf -> root. Each step concatenates the current hash with its sibling,
// hashes the pair, and continues. The final value must equal the anchored root.
let current = sha256(commitSha);
for (const step of chain.steps) {
  const [left, right] = step.order === "lr" ? [current, step.sibling] : [step.sibling, current];
  current = sha256(left + right);
}

console.log(current === chain.merkleRoot ? "PROOF OK" : "PROOF MISMATCH");

The point of doing this yourself is that a scripted check is reproducible evidence of the check, and it doesn’t depend on a dashboard rendering correctly.

5. Download the PDF certificate

When you need something to attach to an email or a contract, the status page offers a per-date PDF certificate, also available directly:

https://timestampgit.dev/api/report/{user}/{repo}/{date}

And for the complete ledger rather than a single day:

curl -s https://timestampgit.dev/api/audit/acme/payments-service -o audit.csv

Interpreting Results and Handling Edge Cases

A valid proof has a precise meaning, and it’s narrower than people assume.

  • What a valid proof says: this commit hash existed at or before the time of that Bitcoin block. Nothing more, nothing less. It does not say the code compiles, that it’s original, or that it’s good. Prior art is about existence and timing.
  • What “pending” means: the nightly worker batches hashes after midnight, builds the Merkle tree, and anchors the root. Bitcoin confirmation then takes several hours — normally around 3 hours — and the proof files are written back to your repository once confirmed. Commits from today will typically not have a final proof until the next day.
  • Private repositories: status URLs for private repos include an encrypted HMAC that is specific to the server instance, so only authorized users can read status. Verification still runs locally in the browser, and the underlying .ots receipt and manifest can be checked without exposing repository contents.
  • If a proof fails: check the boring things first — right repository, right date, and the right manifest. A .ots receipt only verifies against the manifest hash it was created for; pairing it with a different day’s manifest will fail correctly and confusingly.
  • Air-gapped environments: the Docker self-hosted license runs the entire stack — including the verification UI and API — on your own infrastructure, so verification never leaves your network.

How Timestamp GIT Makes Verification Automatic

The reason all of the above is one page and not a weekend project is that anchoring is fully managed. You install the GitHub App once on a monitored repository, and every commit is anchored into Bitcoin automatically each night. No CLI tools, no manual protocol steps, nothing to run on developer machines — which is also why the workflow doesn’t depend on anyone remembering to do it.

Behind that, the pipeline batches commit hashes in a queue, groups them at midnight into per-repository manifest files, builds a Merkle tree, creates OpenTimestamps proofs against public calendars, and anchors the root into Bitcoin. Proof files are then pushed back to a timestamps branch or shadow repository. For teams that need the source to stay entirely out of reach of the service, Enterprise ZK mode uses a 12-line GitHub Action that pushes only commit hashes from your own infrastructure — the service produces verifiable proofs without read access to the source repository.

If you need self-hosted verification, 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; a setup wizard on first launch walks you through connecting your GitHub App and configuring the instance. A time-limited demo license for evaluation is available from the Docker License page.

FAQ

Do I need to install any software to verify a Bitcoin timestamp proof? No. Timestamp GIT’s verification pages run entirely in your browser, and public API endpoints return the Merkle chain data for local checks. You can also download the .ots receipt and verify it offline with standard OpenTimestamps tools if you prefer.

Can I verify a proof without trusting Timestamp GIT? Yes. The proof relies only on SHA-256 and Bitcoin block data, so it is vendor-independent. You can verify the .ots receipt against the Bitcoin blockchain using open tools, even if Timestamp GIT no longer exists.

What if the Bitcoin transaction for my proof isn’t confirmed yet? Bitcoin confirmation typically takes around 3 hours. Until the transaction is confirmed in a block, the proof is pending; after confirmation, it becomes immutable and can be verified in your browser.

How do I verify a proof for a private repository? Private repository status URLs include an encrypted HMAC so only authorized users can view them. You can also download the .ots receipt and manifest from the timestamps branch and verify them locally without exposing repository data.

Conclusion

Browser verification is what turns a timestamp from an internal record into something you can hand to someone who doesn’t trust you — which is the only audience that matters in a dispute. The check takes a URL, a date, and a few seconds of local hashing, and it produces an answer anchored in Bitcoin rather than in a vendor’s database.

If you haven’t set this up yet, the sequence is short: connect a repository to Timestamp GIT via the GitHub App, let the nightly job anchor your commits, then open the status page and verify one date end to end. That single successful verification is the difference between “we have logs” and “we have proof.” If you want the no-CLI setup first, read How to Timestamp Git Commits Without the Command Line next.

Related posts

EU label: AI-generated content