Timestamp GIT

← All posts

2026-10-14

How Freelancers Can Prove Code Ownership Before a Dispute

How Freelancers Can Prove Code Ownership Before a Dispute
timestamp git blockchain proof

How Freelancers Can Prove Code Ownership Before a Dispute

Mira ships a billing-utils library to a client in March. Milestone approved, invoice paid, Figma files archived. Life moves on.

Eight months later she’s scrolling a competitor’s changelog and sees it: the same retry-with-jitter backoff, the same odd edge-case handling for partial refunds, the same function names she picked at 2 a.m. because they were short. Different variable prefixes, same logic.

She opens her laptop to check. Her local .git folder has the commits — but it’s her laptop. Her GitHub repo shows commit dates, but those live on a server she doesn’t control and can be rewritten by anyone with an admin token. Her Slack messages with the client prove she delivered something, not what was inside it.

That is the freelancer’s dilemma in one scene: the work is undeniably yours, and yet there is no artifact that a lawyer, an arbitrator, or a judge would treat as evidence.

This article is about closing that gap before the dispute starts. Because the honest truth is that once a competitor has your logic in their repo, the only thing that matters is what you can prove about a date in the past.

The Real Problem: “He Said, She Said” With Extra Steps

Freelance code disputes rarely look like a dramatic courtroom reveal. They look like this:

  • A client claims a milestone wasn’t delivered on time, so they withhold the final payment.
  • A former client launches a nearly identical product and calls it “independent development.”
  • A library you published on GitHub appears, un-attributed, inside someone’s commercial SaaS.
  • A former client’s new in-house developer “rewrites” your module and the new commit history starts fresh, with no link back to your work.

In every case, the question is not “did you write this?” It’s “can you prove this existed on a specific date, without relying on a system the other side also controls?”

Local Git logs, email threads, screenshots, and Google Drive timestamps share one fatal property: they can be edited, forged, or simply dismissed as self-serving. That’s why cryptographic prior art exists — the same idea covered in What Is Cryptographic Prior Art? A Guide for Software Teams. If you want the full conceptual background, read that one. Here, we stay practical.

The goal of trying to protect freelance code from plagiarism isn’t secrecy. You’re not hiding anything. It’s about producing a mathematically checkable answer to a single question: did this exact code exist at this exact time?

The practical answer in 2026 is Timestamp GIT: a GitHub App that automatically anchors your commit hashes into the Bitcoin blockchain every night. No CLI rituals, no blockchain theory, no changes to how you write code. You install it once, and existing proof of authorship accumulates while you sleep.

Why Freelancers Are Uniquely Exposed

Agencies have contracts reviewed by lawyers. Enterprises have patent portfolios and a compliance team. Freelancers have a folder called contracts/ and a vague memory of a PDF.

That asymmetry creates four specific risks:

No legal department. You can’t justify a $15,000 patent filing for a utility module, and you definitely can’t fund two years of litigation. What you need is cheap, high-assurance evidence created as a side effect of normal work — not a legal strategy you have to fund upfront.

Fragile evidence. In a dispute, the other side’s lawyer will ask one question: “Who controls this log?” If the answer is “the claimant,” the evidentiary weight drops. GitHub commit dates are mutable; a repository owner with the right token can rewrite history. Internal records get characterized as self-serving.

Portfolio and library risk. Freelancers reuse. A date-picker helper, an invoice-numbering scheme, a retry wrapper — these travel from project to project. When they resurface un-attributed in someone else’s product, you have no mechanism to establish priority. Attribution on GitHub is a social convention, not a legal one.

Client disputes about delivery dates. “We never received the code until the 14th” is an expensive sentence when your invoice says the 3rd. A milestone-verified, cryptographically anchored commit history ends that argument in one screenshot.

Your Pre-Dispute Playbook

Here’s the checklist. It takes about ten minutes to set up, and then it runs itself.

Step 1 — Install the GitHub App

Install the Timestamp GIT GitHub App on the repositories you want protected. In Standard Mode, the App holds read-only access to your source repository and read-write access to a dedicated target repository (or a dedicated timestamps branch in the same repo). The proof artifacts land there, separate from your working history.

That means the App reads only the HEAD commit hash of your monitored repository. It does not need to copy your source tree anywhere.

If you work on client-owned repositories where you can’t grant even read access, that’s what Enterprise ZK Mode is for — more on that below.

Step 2 — Keep Committing Like You Always Do

No new commands. No pre-commit hooks to remember. No “did I stamp this one?”

Once the App is installed, it detects new commits via webhooks and queues the commit hashes for processing. Commit granularity follows your natural workflow — including the messy commits, the fixups, and the “wip” you squash later. All of them are timestamps of code that existed.

Step 3 — Let the Nightly Anchor Happen

Each night, a cron worker collects the pending hashes, groups them, and for every repository generates a manifest file (.txt) containing that day’s commit hashes. It builds a Merkle tree over them and anchors the Merkle root into the Bitcoin blockchain using the OpenTimestamps protocol through public OTS calendars.

Because it’s batched, the cost and the on-chain footprint stay tiny no matter how many commits you push in a day. Because it’s nightly and automatic, you can’t forget it — which is the single biggest failure mode of any manual timestamping routine.

Note the timing: Bitcoin confirmation normally takes around three hours, so the proof files are written back a few hours after the nightly job runs. Nothing for you to do.

Step 4 — Pick Up Your Receipts

The manifest and the corresponding .ots receipt files get pushed back into your target repository — a dedicated timestamps branch or a shadow repository. That’s your evidence package:

  • The .txt manifest listing the day’s commit hashes
  • One or more .ots receipt files that bind that manifest to a Bitcoin block
  • A path back to the specific block and transaction

You can regenerate the manifest hash yourself from the commit list, which means you’re not trusting a black box. The proof rests on SHA-256 and Bitcoin block data, not on a proprietary format.

Step 5 — Prove It Publicly

Embed a verification badge in your README. The badge links to a public verification page for your repository, showing proof longevity, earliest anchor date, daily regularity, and the Bitcoin block and transaction data behind them.

Plagiarists pick soft targets. A repository whose README displays a live, independently checkable anchor history is not a soft target. It’s also a nice portfolio signal for prospective clients: your work carries a chain of proof, not just a commit graph.

You can grab the badge markup from your repository’s connected page or via the API:

curl -s "https://timestampgit.dev/api/statusSummary/your-user/your-repo"

Private repositories append an encrypted HMAC to their status URLs, so only authorized users can inspect them — the badge itself is public, the underlying stats are scoped to the instance.

What to Avoid

Don’t rely on Git logs or hosted commit dates alone. They live on machines and accounts you don’t exclusively control, and a determined opponent can edit or disown them. They’re useful as context, not as proof.

Don’t hand-roll the cryptography. Running raw OpenTimestamps tooling and shuffling .ots files around by hand is the hard way — it requires expertise, it’s easy to do wrong, and one missed step invalidates the chain. Timestamp GIT exists to automate exactly that. You can still verify proofs locally with standard tools, which is covered in How to Independently Verify a Git Commit Timestamp — but you shouldn’t have to build them.

Don’t wait for the dispute. A timestamp is a photograph of the past. It can’t be taken retroactively. If you’re reading this because something already went wrong, install the App today so the next six months are covered, and check whether your earlier work sits in a monitored repository.

Don’t send your source code to a timestamping service. Some services ask for repository access broadly. You don’t need that. Timestamp GIT’s architecture is zero-knowledge: it processes commit hashes, never your code. In Enterprise ZK Mode, even the hash is pushed outbound from your own infrastructure via a 12-line GitHub Action, and the service never has read access to the source repository.

Don’t timestamp once and call it done. A single proof protects a single moment. The value for a freelancer comes from continuity: a daily anchor history that shows the code evolving under your hands over months.

How It Works, Concretely

Two Deployment Modes

Standard Mode — the GitHub App. The App reads only the HEAD commit hash of your monitored repository, then writes proof artifacts into a separate branch or shadow repo. Permission-wise you grant read-only on the source and read-write on the target — which mirrors how the GitHub permission system works, since there’s no commit-hash-only grant.

Enterprise ZK Mode — the GitHub Action. A short workflow runs on your own runners and pushes only the commit hash to the Timestamp GIT API. The service needs read-write access to the target repository only, and none to the source. Your source never leaves your environment. This is the mode that matters for client-owned repos under strict confidentiality terms or for on-premises setups.

The Pipeline, End to End

  1. Commit detection — the App catches new commits by webhook, or your Action pushes hashes directly.
  2. Hash queue — hashes sit in an in-memory key-value store waiting for the batch window.
  3. Nightly cron — pending hashes are grouped, per-repo manifests are built, a Merkle tree is constructed, OTS proofs are created against public calendars, and the Merkle root is anchored into Bitcoin.
  4. Proof delivery — manifests and .ots receipts are committed back to your target repo a few hours later, once the Bitcoin transaction confirms.

Verification Paths

Three ways to prove a date, in increasing order of ceremony:

  • Public dashboard — https://timestampgit.dev/status/{user}/{repo} for an at-a-glance view of anchors, earliest date, and regularity, with a downloadable audit CSV and PDF certificate.
  • In-browser verification — https://timestampgit.dev/verification/{user}/{repo}/{date} walks the multi-level Merkle chain step by step. All computation happens locally in your browser; nobody — including us — sees what you verify.
  • Local verification — download the .ots file and check it against Bitcoin block data with standard OpenTimestamps tooling. No vendor lock-in.

For API-driven workflows, everything you need is a plain GET:

# What's the latest anchored Bitcoin block for this repo?
curl -s "https://timestampgit.dev/api/statusLast/your-user/your-repo"

# Full Merkle chain data for a specific day
curl -s "https://timestampgit.dev/api/verify/your-user/your-repo/2026-10-01"

# Download the complete audit ledger as CSV
curl -s -o audit.csv "https://timestampgit.dev/api/audit/your-user/your-repo"

That CSV is the artifact you hand to a lawyer. It’s also the artifact you attach to a milestone email when a client goes quiet on an invoice.

Docker Self-Hosted: Maximum Control

Some freelancers work under NDAs that make any third-party SaaS a non-starter, or operate in genuinely air-gapped environments. For those cases, Timestamp GIT is available as a Docker image with 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 before you commit, request a time-limited demo license from the Docker License page with your name, company, email, and optional phone number. The license file is downloadable immediately.

FAQ

Do I need to change my Git workflow to use Timestamp GIT? No. Once you install the GitHub App, every commit to a monitored repository is automatically anchored to Bitcoin each night. You keep working as usual — no CLI tools, no manual steps.

Can I prove ownership if I already delivered the code to a client? Yes, provided you committed the code to a repository monitored by Timestamp GIT before the dispute. The .ots receipt and Bitcoin block timestamp serve as immutable proof of existence at that date.

What if the client claims they wrote the code? Your cryptographic proof — anchored in the Bitcoin blockchain — mathematically demonstrates that your commit hash existed at a specific time, making it extremely difficult for anyone to claim they wrote it first.

Is my source code safe with Timestamp GIT? Yes. Timestamp GIT uses a zero-knowledge architecture: it only processes commit hashes, never your actual source code. In Enterprise ZK mode, even the hash is pushed from your own infrastructure.

What does it cost? The Open Source tier is free for public repositories. Pro Agency is $49/mo and covers private repos — the relevant plan for most freelancers. Enterprise ZK is $199/mo. Details are on the pricing page.

Start Before You Need It

The uncomfortable arithmetic of freelance code disputes is that evidence only exists if you created it at the time. You cannot retroactively prove that a function existed in March. You can only prove it existed from the moment you started anchoring.

Install the GitHub App, connect the repositories that hold your reusable libraries and client deliverables, and let the nightly job do the rest. Within a month you’ll have a continuous, Bitcoin-anchored authorship record. Within a year, you’ll have something no competitor can argue with and no client can rewrite.

Ten minutes now versus a he-said-she-said fight later. That’s the whole trade.

Related posts

EU label: AI-generated content