Timestamp GIT

← All posts

2026-11-20

Set Up IP Protection With a Single GitHub App Install

Set Up IP Protection With a Single GitHub App Install
timestamp git blockchain proof

Set Up IP Protection With a Single GitHub App Install

You do not need a legal budget, a CLI toolchain, or a change to how your team writes code to get cryptographic proof that your repository existed at a specific moment. You need one install.

This guide walks through the entire setup for a github app for intellectual property protection: install the Timestamp GIT GitHub App, pick your repositories, let the nightly automation batch your commit hashes and anchor them into Bitcoin, then confirm the proof is real. Every step below is a click, a setting, or a short config file. No developer on your team types a new command, and no source code ever leaves your GitHub organization.

What you end up with: an immutable .ots receipt per day, a public status page backed by Bitcoin block data, a badge in your README, and an audit CSV or PDF certificate you can hand to a lawyer or an auditor.

Why a GitHub App Is the Fastest Route to IP Protection

The hard way to do this is to manually anchor commits yourself — running the OpenTimestamps tooling by hand and tracking Bitcoin confirmations for each batch. It works, but it is error-prone, it depends on one person remembering to do it, and it collapses the moment you have five developers and a hundred commits a day.

The managed way is a single GitHub App installation. Timestamp GIT sits on top of the same cryptographic primitives, but hides the protocol behind automation:

  • Install once. No CLI, no local tooling, nothing to install on developer machines.
  • Automatic detection. Every new commit to a monitored repository is picked up via webhooks.
  • Nightly anchoring. Hashes are batched at midnight, Merkle-rooted, and anchored into Bitcoin through OpenTimestamps.
  • Delivered back to you. Manifests and .ots receipts land in a dedicated branch or a separate shadow repository.
  • Zero-knowledge. Only commit hashes are processed. Your source is never read, copied, or stored.

If you want the strategic background on why this matters legally before you start clicking, read Prove Prior Art Before You File: A Founder’s Guide. This article stays focused on setup.

Prerequisites: What You Need Before You Start

  • A GitHub account with admin rights on the repository — or the organization — you want to protect. You cannot install a GitHub App on a repo you only have write access to.
  • A Timestamp GIT account. The Open Source tier is free for public repositories; private repositories require a paid plan.
  • A basic mental model of Git. You should know that a commit has a SHA-1 or SHA-256 hash. That’s the extent of the cryptography knowledge required.
  • A decision on where proofs live. Same repository on a dedicated branch, or a separate shadow repository. A shadow repo keeps your main repository clean but requires a target repo you can grant write access to.
  • Optional: Docker. Only if you plan to self-host later — covered in a later section.

Step 1: Install the Timestamp GIT GitHub App

  1. Go to timestampgit.dev and sign in with GitHub.
  2. Click Install GitHub App.
  3. Choose All repositories or Only select repositories, then pick the repos you want monitored.
  4. Review the permissions GitHub shows you. In standard mode the app needs:
    • Read-only access to your source repositories — GitHub does not offer commit-hash-only access, so read access is the minimum.
    • Read-write access to a target repository where proofs are written.
  5. Confirm. You land on the dashboard with your connected repositories listed.

You can revisit and change the repository selection at any time from the GitHub App settings page; the app does not require a reinstall to pick up newly added repos.

Step 2: Configure Your Repository Settings

Select the repository you just connected. Two decisions matter here:

Where do proofs go? Either a dedicated timestamps branch in the same repository, or a separate shadow repository. If you are timestamping a repository you plan to open-source later, a shadow repo keeps the proof history out of the public tree until you want it visible.

When does anchoring run? Nightly at midnight is the default and the recommended setting — batching many commits into one Merkle root is what makes daily proofs cheap and consistent. Leaving the schedule alone is almost always the right call.

Then copy your badge embed code. Open the repository connected page (/connected/{user}/{repo}) for a live preview of the Shields.io verification badge and the exact Markdown to paste.

One privacy note: status URLs for private repositories carry an encrypted HMAC specific to your server instance, so only authorized users can read the status of a private repo. Do not strip that parameter when you copy a URL.

Save the settings. Commit hashes start flowing into the queue immediately.

Step 3: Let the Automation Run

There is nothing to do here except push code. Behind the scenes:

  1. Commit detection — the GitHub App sees new commits via webhooks.
  2. Hash queue — commit hashes accumulate in an in-memory key-value store for batching.
  3. Midnight cron worker — a worker groups all pending hashes, writes a manifest text file per repository, builds a Merkle tree natively, generates OpenTimestamps proofs against public OTS calendars, and anchors the Merkle root into Bitcoin.
  4. Proof delivery — the manifest and .ots receipt files are pushed back to your timestamps branch or shadow repo.

Budget for the Bitcoin confirmation window. The batch is submitted at midnight, but inclusion in a block normally takes around three hours. In practice, proofs from a commit pushed today are available tomorrow morning.

Again on the zero-knowledge point, because it is the thing auditors ask about: the service only ever handles commit hashes. Your diff, your files, your secrets — none of it is transmitted.

Step 4: Add the Verification Badge to Your README

Paste the snippet from the connected page into your README. It looks roughly like this — use the exact URL the app gives you, not the placeholder:

<!-- Copy the real snippet from timestampgit.dev/connected/{user}/{repo} -->
[![Bitcoin-timestamped](BADGE_URL_FROM_TIMESTAMPGIT)](https://timestampgit.dev/status/your-user/your-repo)

Anyone who clicks through reaches the public status page and can re-verify the timestamp from the .ots file themselves. That public, click-through verification path is what turns a proprietary claim into evidence a third party will accept.

How to Confirm It Worked

Give it a night, then check three things.

1. The repository status page. Open /status/{user}/{repo}. You should see proof longevity, earliest anchor date, daily regularity, the Bitcoin block and transaction data for each anchor, and a calendar heatmap. A gap in the heatmap means a day with no commits — not a failure.

2. The API, if you want it in a dashboard.

# Last anchored Bitcoin block
curl https://timestampgit.dev/api/statusLast/your-user/your-repo

# Total stamped commit count
curl https://timestampgit.dev/api/statusCount/your-user/your-repo

# Full audit ledger as CSV
curl -O https://timestampgit.dev/api/audit/your-user/your-repo

3. A PDF certificate for a specific date. Download it for any anchored day:

curl -O https://timestampgit.dev/api/report/your-user/your-repo/2026-11-19

For the full walkthrough of what a Merkle chain verification actually looks like step by step — all of it computed locally in your browser — see How to Verify a Bitcoin Timestamp Proof for Your Code. The short version: the .ots file and manifest are standard OpenTimestamps proofs, verifiable against Bitcoin block data by any compatible tool. No lock-in, no dependency on us staying in business.

Optional: Self-Host With Docker for Air-Gapped Environments

For maximum control — regulated environments, air-gapped networks, or teams that want the service on their own infrastructure — Timestamp GIT ships as a Docker image under a self-hosted license.

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.

To evaluate it, request a time-limited demo license from the Docker License page with your name, company, email, and optional phone number; you get a license file to download. Self-hosting means managing your own GitHub App and infrastructure, but the zero-knowledge guarantees are identical.

Troubleshooting Common Setup Issues

  • Installation fails or permissions look wrong. You need admin rights on the repo or org, and in standard mode the app must also be granted access to the target repository where proofs are written. A missing target repo is the most common cause of “connected but nothing happening.”
  • No proofs after 24 hours. Confirm the repository is actually receiving commits and that the app was not paused from GitHub’s side. Check the status page for errors before filing anything — an idle repo produces no manifest, which is expected behavior.
  • Badge renders as a broken image. Re-copy the badge URL from the connected page. For private repos, the URL must include the encrypted HMAC; a trimmed URL will fail.
  • Anchor is late. Bitcoin block times vary. A delayed confirmation still anchors — once the block exists, the proof is immutable. Nothing needs to be re-run.
  • Proofs appear in an unexpected place. Check whether the repo is configured for a same-repo branch or a shadow repo; switching modes does not rewrite historical proofs.

FAQ

Do I need to change my Git workflow to use Timestamp GIT? No. Once the GitHub App is installed, it automatically detects new commits and anchors them nightly. Developers continue using Git as usual — no new commands or tools to learn.

What GitHub permissions does Timestamp GIT require? In standard mode, the app needs read-only access to your source repositories (to read commit hashes) and read-write access to a target repository where proofs are stored. Enterprise ZK mode swaps that around with a GitHub Action that pushes only the commit hash from your own infrastructure, so the service needs no read access to the source repository at all.

How long does it take for a commit to be timestamped on Bitcoin? Commit hashes are batched and anchored once per day at midnight. After the batch is submitted to the Bitcoin blockchain via OpenTimestamps, confirmation typically takes around 3 hours — so proofs are usually available the next morning.

Can I verify the timestamp proof independently without Timestamp GIT? Yes. The .ots receipt file and manifest are standard OpenTimestamps proofs. You can verify them using any OpenTimestamps-compatible tool against the Bitcoin blockchain, ensuring vendor independence.

The Install Is the Whole Project

One GitHub App installation, one repository selection, one settings page. After that, IP protection becomes a background property of your repository rather than a quarterly chore: every commit hash batched nightly, every batch Merkle-rooted into a Bitcoin block, every proof written back to a branch you control and verifiable by anyone with the .ots file.

That is the entire adoption cost. If you have been putting off prior-art protection because it looked like a legal process with an engineering tax attached, start with the free Open Source tier on a public repo today and watch the first proof land tomorrow morning — get started here. For teams evaluating the tooling landscape first, Best Tools to Timestamp Source Code for Auditors compares the options.

Related posts

EU label: AI-generated content