What a KNOT HEAD is

1,110 node runners,
algorithmically generated.

They may have failed,but they will live on as spam forever

Every KNOT HEAD is a portrait of somebody who keeps a node up: the beard, the tinfoil hat, the red cap, the coke bottle glasses, the small computer humming in the corner. Each one is inscribed whole onto Bitcoin as a single self contained SVG.

KNOT HEADS was born out of one of Bitcoin's great arguments about what belongs in Bitcoin. The argument is over. The heads are still on Bitcoin, which was rather the point.

Tinfoil supplied. Opinions your own.every one of them runs a node. that is the entire premise.

Start here

The short version.

  1. You send one payment to one address.
  2. That payment inscribes one KNOT HEAD straight to your own wallet.
  3. Sign one payment with a supported Bitcoin wallet. Your KNOT HEAD is inscribed straight to your own address. No second payment, no waiting for a date.
1The set is committed1,110 heads and their addressesare fixed before minting opens.2You name an addressThe wallet address your headshould arrive at. Yours, not ours.3You send one paymentOne exact amount, one address,signed by a supported wallet.4The head arrivesThe inscription is built and sentto your address automatically.
There is no fifth step. The inscription that arrives is the finished artwork, held at your own address, and nothing about it changes afterwards.

The algorithm

One pen-line motif, algorithmically generated.

Each head is algorithmically generated as a single wobbling ink line over flat riso colour. The renderer preserves the intended wobble and slight misregistration without any manual-art step.

The backgrounds come from the same world as the subjects: perfboard, server racks, terminal scroll, redaction bars. 12 trait categories decide the rest, from the beard down to which single board computer is humming in the corner. No filtering, no upscaler, no borrowed house style.

Look at the heads

What you actually own

Four things that are already true.

None of them depends on a roadmap, a promise, or this website still being here next year.

  1. 1,110 heads, then the door closes

    The whole set, and which payment address belongs to which head, were fixed and published before minting opened. Nobody can add a head, swap an assignment, or quietly re-roll a rare one after seeing who bought. When the last one confirms, that is the collection, permanently.

  2. One payment. One permanent inscription ID

    You pay once. The inscription that payment creates is the thing you own, at your own address, with the whole artwork already inside it. There is no second payment, no claim to make later and no replacement token.

  3. It is an ordinary inscription

    Your head is drawn, inscribed and delivered in the same breath as your payment. When it lands in your wallet, the picture is already there. It is a plain Ordinals inscription from the first block it appears in, so it moves, displays and sells on exactly the same rails as any other one.

  4. Being early is a fact, not a promise

    Your number is written into the chain in the order you turned up, and it stays there. We are not going to make a claim about price. We will tell you that anyone can check when you arrived, forever, without asking us for permission or for a database export.

Only now, the proof

How the assignment is kept honest.

The order is the whole trick. The artwork set and the payment address belonging to each head are published before anybody buys, so the answer cannot be changed after seeing who bought. Which head you get is decided by the address you pay, and every address was committed to before minting opened. Your own payment is the proof of which one you chose.

1Provenance roots published2Payment addresses committed to the roots3You are quoted one exact amount4Your payment confirms on Bitcoin5The inscription is built and broadcast6It confirms at your own address7Indexers resolve the artwork and traits
Stages run in this order and no other. The moment your payment confirms, the inscription is built and broadcast to the address you gave. You do not sign anything else and you are not charged again.
In more detail: what each stage waits for

The full collection is hashed and the commitment published before the first mint. Each order takes the next number and holds it once the payment reaches the configured confirmation depth, which is why a payment in the mempool is never treated as a mint.

The address you are asked to pay is inside the published commitment for one specific artwork, so paying it is the choice. Your own payment transaction is what timestamps that choice on Bitcoin, and it costs nothing extra to do so.

Once the payment confirms, the inscription carrying that artwork is built and broadcast to the address you gave. Set membership, the address-to-artwork assignment and the SVG hash can all be checked independently.

Cryptographic evidence: the commitment, in parts

The commitment is not one number. It is a set of published values, each pinning a different thing that could otherwise be changed quietly after the fact.

Manifest hash
Pins the descriptor of the ordered dataset: how many assets, in what order, under which schema.
Merkle root
Commits to every asset in the set, so a single head can be proved a member of the collection without publishing the rest early.
Commitment hash
Binds the manifest, the root and the mint configuration into one value, so the rules cannot be edited after minting opens.
Generator hash
Pins the code that generates the artwork, so a refactor cannot move a byte of a delivered head.
Metadata schema hash
Pins the shape of the metadata written on chain beside each head.

No value is printed on this page. They are live readings, and a page that has not read them should not pretend otherwise. The checkout prints the commitment for your own order before you pay anything.

Transaction evidence: checking one mint end to end

You make exactly one Bitcoin transaction: the payment. The transaction that carries the artwork to your address is funded entirely by that payment and is built for you, so there is nothing else for you to sign or send.

Before you pay
The checkout shows one address and one exact amount, and that amount is everything you pay. A supported wallet prints the RBF-enabled transaction and its outputs before you sign it.
While it settles
The mint screen keeps the payment sighting, its confirmation depth and the inscription broadcast as separate facts, with the transaction IDs to check each one yourself. It never calls a slow fee market a failure.
After it lands
The token page recomputes the content hash of the artwork your browser drew and holds it against the hash recorded on chain. Verified, mismatch and not enough data are three different answers, and it never collapses them into one.

Open any head and check its content hash

The collection was locked first

Before minting opened, the ordered dataset and the map from payment address to artwork were committed to published roots. No wallet, browser or operator can pick an artwork after a payment is made, because moving an assignment would need a different address than the one already paid.

Bytes, not vibes

Every final artwork is an exact self contained SVG. Its SHA-256 and the exact script that carries it on chain are locked before minting, so nobody can quietly swap the bytes later.

Confirmations decide supply

An order is not a mint. A payment in the mempool is not a confirmed mint. A position becomes final only at the configured confirmation depth. An order whose payment is ambiguous is quarantined until it is reconciled against the chain exactly, and a paid address is never handed to somebody else.

One source of truth

Mint records, ownership and transfers are checked against Bitcoin and the canonical collection index. The chain is the source of truth, not a private inventory somebody can edit.

Check a head's content hash yourself

Secondary, and load bearing

The artwork bytes are frozen too.

A locked collection is only worth as much as the evidence binding each SVG to the address somebody pays for it. The transaction protocol and hashes are part of that same commitment.

Protocol integrity: knotheads/standard-ord/v1

knotheads/standard-ord/v1 binds the offline manifest, the address-to-artwork assignment, the exact script that carries each SVG, and the public proof format. Before spending your payment, the service recomputes every committed hash and fails closed on any mismatch.

Trait weights and final rarity come from the published dataset and its hash, so anyone can recompute the result for a head they own and hold it against what they were shown.

The last step

Go and take a number.

The set is algorithmically generated, the count is fixed, and the exact cost is on screen before you send anything. The only thing left undecided is which head ends up being yours.