How to Prove Code Ownership in a Client Payment Dispute
You delivered the feature-complete build on a Friday. Three sprints, four months, one signed statement of work. Monday the client goes quiet. Two weeks later their operations manager writes: “We never received the final code, and what we did see didn’t work as agreed.” Then the invoices stop.
This is the moment every freelancer and small agency dreads, and it’s the exact moment where knowing how to prove code ownership during a client payment dispute stops being a theoretical concern and becomes the difference between getting paid and writing off four months of work.
The Freelancer’s Nightmare: When a Client Refuses to Pay
The scenario repeats with almost mechanical regularity:
- You push the final commit, hand over access, and send the last invoice.
- The client disputes scope, claims non-delivery, or invents a defect list two months after sign-off.
- They have a lawyer on retainer. You have a Gmail account and a Notion page.
The core problem isn’t that you’re wrong. It’s that without independent proof of what was delivered and when, the dispute collapses into a credibility contest — and credibility contests are won by whoever has deeper pockets and better paperwork.
Timestamp GIT is the automated safety net for exactly this situation. It’s a GitHub App: you install it once on a repository, and every commit you make is cryptographically anchored into the Bitcoin blockchain overnight, with no CLI tools and no manual steps. You keep working normally; the proof accumulates in the background. When a client dispute starts, you don’t argue about dates — you hand over a verifiable receipt.
This article focuses on the payment-dispute use case. For the broader prior-art picture — patent trolls, employee disputes, clean-room defenses — see our related posts at the end.
Why Traditional Evidence Fails in a Payment Dispute
Most developers assume their Git history is proof. It isn’t, at least not on its own:
- Git commit dates are not trustworthy evidence. The committer and author dates are just metadata. Anyone with write access can rewrite history, and even without rewriting, a date field a developer typed on their own machine proves nothing to a third party.
- The history lives on servers you don’t control. GitHub can be edited, force-pushed, or — worst case — lose access entirely if the repo belongs to the client.
- Email threads and chat logs are easy to forge or delete. A screenshot of a Slack message carries very little weight.
- Internal logs get dismissed as self-serving. In a legal audit, “our own database says we shipped it” is roughly as persuasive as a hand-written note.
Courts, mediators, and arbitrators look for something different: independent, tamper-evident proof that a third party can verify without having to trust either side.
That’s what a Bitcoin anchor gives you. Timestamp GIT’s proofs are anchored in the Bitcoin blockchain via the OpenTimestamps protocol. Once a hash is confirmed in a block, no entity on earth can alter or forge it — including the company running the service. Timestamp GIT could disappear tomorrow and your proof would still be verifiable, offline, by you or anyone else.
The Playbook: How to Protect Yourself Before and During a Dispute
1. Before the project starts: install the GitHub App
Install the Timestamp GIT GitHub App on the repository you’ll be working in — yours, or the client’s with their permission (more on that in the FAQ). That’s the entire setup. There are no CLI tools to install on your developers’ machines and no workflow changes.
In Standard Mode, the app reads only the HEAD commit hash of monitored repositories. It requires read-only access to the source repo and read-write access to a target repo, which can be the same repository or a separate one.
2. During the project: just keep committing
This is the part that matters for a dispute: your commit messages are the narrative of delivery. Reference the contract.
git checkout -b feature/checkout-flow
git add .
git commit -m "feat: complete checkout flow per SOW section 4.2"
git push origin feature/checkout-flow
That’s all you do differently. Each night, Timestamp GIT groups the pending commit hashes, creates a manifest (.txt) for each repository, builds a Merkle tree, generates OpenTimestamps proofs using public calendars, and anchors the Merkle root into Bitcoin. The manifest and .ots receipt files are pushed back into your repository on a dedicated timestamps branch or shadow repo.
One thing to plan around: Bitcoin confirmation typically takes around 3 hours, so the proof files land a few hours after the nightly run. Don’t schedule your handover for the same evening you need the receipt.
3. If a dispute arises: pull the evidence
Your repository status page shows proof longevity, the earliest anchor date, daily regularity, and the Bitcoin block and transaction data behind each day. From there you can export the two documents that matter in a billing discussion:
# Full audit ledger for the whole engagement, as CSV
curl -L "https://timestampgit.dev/api/audit/youruser/client-project" \
-o audit-ledger.csv
# PDF certificate for one specific delivery date
curl -L "https://timestampgit.dev/api/report/youruser/client-project/2026-10-14" \
-o certificate-2026-10-14.pdf
The CSV gives you the exact commits and their Bitcoin block confirmations — a date-by-date delivery record. The PDF certificate packages a single day’s timestamp into a document you can attach to an email or hand to a lawyer.
4. Present the evidence, don’t argue about it
Send the .ots receipt files and the verification link. The point is that the client — or their attorney — does not have to trust you. They can check the timestamp independently against the Bitcoin blockchain using standard OpenTimestamps tools. Timestamp GIT also offers a web viewer that walks through the multi-level Merkle chain step by step, computing everything locally in your browser so nobody sees what you verify.
5. For extra assurance: embed a verification badge
The repository status pages provide embeddable badges for your README. A visible “commits anchored to Bitcoin” badge signals professionalism and quietly tells a would-be disputed invoice that the delivery record is not something you can be argued out of. Badge URLs and ready-made Markdown snippets come from the connected-repo page after installation.
What to Avoid in a Payment Dispute
- Don’t rely solely on GitHub’s commit history. It can be altered, and it will be characterized as self-reported.
- Don’t wait until a dispute starts to set up timestamping. Proof is only credible if it existed before the conflict — retroactive proof is impossible.
- Don’t dump your whole codebase on the client mid-dispute. Timestamp GIT’s zero-knowledge design means you can share the hash proofs and certificates instead of the source, unless a court compels otherwise.
- Don’t hand-roll the cryptography. You could try to assemble an OpenTimestamps proof chain manually — that’s the hard way, and a single mistake in the workflow leaves you with nothing. The managed GitHub App handles detection, batching, anchoring, and delivery automatically.
How Timestamp GIT Fits Into Your Workflow
Standard Mode (GitHub App). Install once, connect the repo, done. The app detects new commits via webhooks, and pending hashes are queued for the nightly worker. You get automatic proof delivery into your timestamps branch without touching a thing.
Enterprise ZK Mode. For teams that would rather their hashes never leave their own infrastructure, a 12-line GitHub Action runs in your environment and pushes only the commit hash to the Timestamp GIT API. In this mode no read access to the source repository is required — you just install the Action.
Self-hosted. For air-gapped or highly regulated environments, Timestamp GIT ships as a Docker image with a time-limited demo license available through the Docker License page. 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 app is then available at http://localhost:8080, and a setup wizard walks you through connecting your GitHub App and configuring the instance.
Verification. Whichever mode you run, verification is the same: download the .ots file and check it against the Bitcoin blockchain with standard OpenTimestamps tools, or use the viewer and PDF reports. The proof rests only on SHA-256 and Bitcoin block data — no proprietary technology, no lock-in.
Pricing follows the same shape: Open Source is free for public repos, Pro Agency is $49/mo for private repos, and Enterprise ZK is $199/mo with the GitHub Action workflow.
FAQ
Can I use Timestamp GIT if the client owns the repository?
Yes. You can install the GitHub App on the client’s repository with their permission, or you can set up a shadow repository that you control. In Standard Mode, the app needs read-only access to the source repo and read-write access to a target repo (which can be the same or a separate repo). In Enterprise ZK Mode, a GitHub Action on your infrastructure pushes only the commit hash, so no read access to the source repo is required.
What if the client deletes the repository?
Your proofs are safe. Timestamp GIT pushes the manifest and .ots receipt files to a dedicated timestamps branch or shadow repository that you control. Additionally, the Bitcoin blockchain record is permanent and immutable. Even if the client deletes their repo, you retain the cryptographic proof of your commits.
How long does it take for a timestamp to be confirmed?
Bitcoin confirmation typically takes around 3 hours. Timestamp GIT batches commits nightly, anchors the Merkle root into a Bitcoin transaction, and then writes the proof files back to your repository. You’ll have a verifiable timestamp within a few hours after the nightly run.
Is Timestamp GIT admissible in court?
Timestamp GIT provides court-ready evidence using globally recognized cryptographic standards: SHA-256 hashing, the OpenTimestamps protocol, and the Bitcoin blockchain. The proofs are immutable and independently verifiable by anyone. However, admissibility depends on jurisdiction and specific legal context, so consult with a qualified attorney.
The Bottom Line
A payment dispute is a documentation problem long before it’s a legal problem. The developers who get paid are the ones who can point at a record that neither side controls and say: here is what existed, and here is the block that proves it.
That’s the whole argument for installing the GitHub App before your next engagement rather than after your next unpaid invoice. It takes one install, changes nothing in your daily workflow, and turns your normal commit history into evidence that no client, lawyer, or mediator can argue with.
Start with your next repository — free for public repos, and a couple of minutes of setup either way.
Related posts
- OpenTimestamps Alternative: Managed GitHub App for Every Commit
- Self-Hosted Git Timestamps: Docker Setup & License Guide
- GitHub App Blockchain Timestamp Setup: Install Once, Timestamp Forever