orphograph

Anchor any file to the Bitcoin blockchain in about ten seconds.

For photographers, journalists, indie creators, and developers who need to

prove a file existed before a given moment — especially before an AI model

saw it. Files never leave the browser; only the 32-byte SHA-256 fingerprint

is submitted. Free tier (3 anchors/24h), $19 Writer Pack (10 anchors), $9/mo

Standing Order (unlimited), $19/mo Creator (capture-time app + API + verifier badge).

Quick demo

Four steps a developer can run from a terminal, no signup, no install

beyond `curl` and `shasum`.

1. Compute the SHA-256 of any file on disk:

shasum -a 256 ~/Pictures/my-photo.jpg
   # → 3f8c1b...  my-photo.jpg

2. Submit the hash to the public anchor endpoint:

curl -sS -X POST https://orphograph.com/api/anchor \
        -H "Content-Type: application/json" \
        -d '{"hash_hex":""}'

The response is a JSON receipt with a `receipt_id` and a list of the

OpenTimestamps calendars that accepted the submission.

3. Pull the receipt back later by ID (or visit `/r/`):

curl -sS https://orphograph.com/api/verify/

4. Verify offline against the original file with the standalone verifier

(no orphograph code, MIT, ~100 lines of stdlib Python):

# Single file with an inclusion proof:
   python3 dist/orphograph-verify/verify.py file \
       --file ~/Pictures/my-photo.jpg \
       --proof receipts//proof.json
   # Whole folder against its manifest:
   python3 dist/orphograph-verify/verify.py folder \
       --dir ~/Pictures/evidence \
       --manifest receipts//manifest.json

The verifier re-hashes the file (or walks the folder) locally and

confirms the result reproduces the manifest's root. Add `--ots

.ots` to also invoke the OpenTimestamps client and check the

chain witness references the same root.

MCP server (Model Context Protocol)

Orphograph ships an MCP server: a single stdlib-only Python file (682

lines, MIT) that implements the Model Context Protocol — JSON-RPC 2.0 over

stdio, protocol version `2024-11-05`, with the `initialize`, `tools/list`,

and `tools/call` methods implemented directly, no SDK — so AI agents and

MCP hosts (Claude Code, Claude Desktop, or any MCP client) can anchor and

verify files as tool calls.

Listed in the official MCP registry as `io.github.Orphograph/orphograph`.

MCP tools exposed (full JSON Schemas in `mcp/manifest.json`):

Quickstart (stdio transport):

Also on PyPI: `pip install orphograph-mcp` (stdlib-only; same server).

curl -sSL https://orphograph.com/mcp/orphograph_mcp.py -o orphograph_mcp.py
claude mcp add orphograph -- python3 orphograph_mcp.py

The free tier needs no API key; set `ORPHO_API_KEY` to use vault features.

An MCPB bundle is attached to release `mcp-v0.1.1`, and

`mcp/Dockerfile` builds a minimal container for MCP

directory crawlers — the server starts and answers MCP introspection with

no configuration. Full tool schemas and options: `mcp/README.md`.

Architecture

Python 3.11+ stdlib only on the server (`http.server`, `urllib`, `hashlib`,

`json`, `secrets`, `fcntl`) — zero pip dependencies in the anchor engine.

Vanilla HTML + CSS + JS on the client, hashing via WebCrypto

`SubtleCrypto.digest` so file bytes never leave the browser. Each anchor

fans out a single 32-byte POST to five independent OpenTimestamps

calendars (a.pool, b.pool, alice, finney, btc.catallaxy); the calendars

batch many users' hashes into a single Merkle root and write the root to

Bitcoin roughly hourly, which is why our marginal on-chain cost is

effectively zero. The `.ots` proofs are stored per-receipt and verify

against the public Bitcoin chain forever, with or without us. Bitcoin

custody is receive-only: a single watch-only address printed in

`btc_address.txt` accepts payments; no signing keys live on production

hosts.

Why this exists

By spring 2026 a large share of new images circulating online are

AI-generated or AI-modified. Watermarks can be stripped, C2PA labels can

be re-signed, EXIF is one shell command away from being anything you

want. What survives that is cryptographic proof — a Bitcoin block that

already existed at a known time, with the hash of your file committed

inside it. Orphograph is the cheapest, most boring way to put a

fingerprint of your work into that block before anyone disputes it.

Long-form on the thesis: /blog/written-by-an-ai.

Privacy properties

What touches what, in one table.

Repo structure

orphograph/
├── server/                       Python stdlib HTTP server + anchor engine
│   ├── engine.py                anchor + verify core (the file in this README)
│   ├── app.py                   ThreadingHTTPServer with /api/anchor /api/verify
│   ├── verify_cli.py            standalone receipt verifier (no engine imports)
│   ├── auth.py                  magic-link tokens + HttpOnly session cookies
│   ├── credits.py               append-only Pack claim-code ledger
│   ├── stripe_webhook.py        HMAC signature verify + idempotent handler
│   ├── subscriptions.py         Personal-tier state derived from Stripe
│   ├── mailer.py                Resend HTTP send (inert when key unset)
│   ├── rate_limit.py            persistent token bucket
│   ├── file_lock.py             fcntl.flock helper for ledger atomicity
│   ├── upgrade_worker.py        OTS upgrade fetcher (cron)
│   ├── expire_worker.py         free-tier receipt pruner (cron)
│   └── gdpr.py                  /api/me/export + /api/me/delete
│
├── web/                          vanilla HTML/CSS/JS — no bundler, no framework
│   ├── index.html, app.js       landing + drop zone + verify section
│   ├── account.html, account.js Personal-tier dashboard
│   ├── signin.html, signin.js   magic-link request form
│   ├── receipt.html, receipt.js print-friendly receipt at /r/
│   ├── style.css                dark glassmorphism, neon-green accent
│   └── terms.html, privacy.html legal pages
│
├── content/blog/                 markdown blog posts (SEO + manifesto)
│   ├── written-by-an-ai.md
│   └── prove-photo-existed-before-ai.md
│
├── tests/                        pytest suite (~98 cases, all stdlib)
│   └── test_*.py                engine / verifier / credits / rate_limit /
│                                 auth / stripe / subscriptions / gdpr / ui
│
├── marketplace/orphograph-plugin/  Claude Code plugin
│   ├── README.md
│   └── skills/anchor, skills/verify
│
├── lightroom-plugin/             Adobe Lightroom Classic plugin (Lua)
│
├── capture/                      desktop capture daemon (Creator tier)
│
├── dist/orphograph-verify/       MIT standalone verifier (vendorable)
│
├── scripts/                      operational helpers
│   ├── smoke_test.sh            end-to-end live OTS calendar test
│   ├── dev_setup.sh             fresh-clone sanity check
│   ├── init_volume.sh           container entrypoint (Fly)
│   ├── upgrade_cron.sh          OTS upgrade scheduler
│   ├── expire_cron.sh           free-tier expiry scheduler
│   └── refund_pack.py           zero a claim code after a Stripe refund
│
└── deploy/                       deploy + ops docs
    ├── FLY_PREFLIGHT.md
    ├── EMAIL_AND_LEGAL_COMPLIANCE.md
    ├── PAYOUT.md
    ├── RUNBOOK.md
    └── launch_drafts/

Local dev

git clone https://github.com/orphograph/orphograph ~/orphograph
cd ~/orphograph
bash scripts/dev_setup.sh           # offline checks + verifier roundtrip
python3 server/app.py               # serves http://127.0.0.1:8989

Run the test suite at any time:

python3 -m pytest tests/ -q

The smoke test hits live OTS calendars and requires network:

bash scripts/smoke_test.sh

Production deploy

Single-container Fly.io with a mounted volume for `receipts/` and the

JSONL ledgers; Stripe webhook verification, Resend for transactional

email, CSP `default-src 'self'`. Step-by-step in

`deploy/FLY_PREFLIGHT.md`.

Pricing

The `$19 / $9` price points are set deliberately low.

The wedge is browser-based UX plus the open-source verifier — not the

cryptography, which is the public OpenTimestamps protocol.

License

• `dist/orphograph-verify/` — MIT. Vendor it, ship it, audit it. This

is the trust artifact: a receipt produced today must verify against

Bitcoin five years from now even if orphograph.com no longer exists.

• `marketplace/orphograph-plugin/` — MIT.
• Everything else — private until launch decisions settle. The founder

retains the option to open-source after six months of customer signal.

On the guarantee

The privacy contract of Orphograph is structural, not promissory.

Files are hashed in the user's browser; only the SHA-256 (and SHA-512)

fingerprint is transmitted. The server cannot reconstruct, identify,

or retransmit the file, because it never receives the file. This

property holds independently of who maintains the code.