Bitcoin finally has human-readable names that nobody can seize, expire, or reroute. That is the promise of Spaces Protocol: a Bitcoin-native naming system where community identifiers such as @bitcoin are auctioned on-chain, bids are burned, and individual handles live off-chain under a 32-byte Merkle root anchored to Bitcoin’s proof of work.
If you have ever tried to send sats to a 62-character address, paste an npub into a group chat, or explain why “your Lightning invoice is the QR code, not your name,” you already know the problem. Spaces Protocol is the missing identity layer: memorable, permissionless, and as hard to revoke as a confirmed Bitcoin transaction.
This post is written in the spirit of the early Spaces coverage that circulated when auctions first went live including the January 2025 Bitcoin Daily News recap on Spaces auctions and updated for where the protocol stands now: mainnet issuance, Trust Anchor verification, Nacho on mobile, and Fabric SDKs that resolve alice@bitcoin in a few lines of code.
The goal is simple. Get a handle. Verify it locally. Build on it. Tell someone else.
Why Bitcoin needed a naming protocol
Bitcoin already solved money. It did not solve names.
Every other stack patched the gap with trust:
- DNS and ICANN can seize a domain.
- Certificate authorities can revoke a TLS cert.
- ENS usually depends on Ethereum plus a resolver you do not run.
- NIP-05 still bottoms out in DNS.
Spaces takes the opposite path. Top-level Spaces are community identifiers, limited to about 10 auctions per day and roughly 3,600 per year. Each Space is represented as a Bitcoin UTXO. Under that Space, operators can issue millions of individual identities subspaces or handles such as alice@bitcoin with a tiny on-chain footprint. Once issued, a handle is not supposed to be taken down by the community that created it.
That design matters because identity is not a side quest. Wallets, Nostr, Lightning, peer-to-peer apps, and AI agents all need a stable name that maps to keys. If the name lives on someone else’s server, it is not sovereign. If it lives on Bitcoin, it is.
What Spaces Protocol actually is
Spaces Protocol is a naming protocol native to Bitcoin. Names live off-chain. Bitcoin anchors trust. No new chain. No soft fork required for the base layer. No protocol token. BTC is the currency. Auction proceeds are burned.
Think of a Space as a top-level domain that a community wins in public. Think of a handle as the username inside that community. The syntax looks like email on purpose:
- alice@bitcoin
- bob@nostr
- you@tabconf
It is easier to say out loud than an npub. It can still sign like a public key. And resolution does not require you to trust the website that first showed you the name.
The official site puts the trust model in one line: no authority can revoke what Bitcoin has confirmed.
How it works without bloating the chain
The architecture is a three-stage pipeline.
Stage 1: Auction the top-level Space on Bitcoin.
Users bid in BTC. Auctions run on the order of ten days. Highest bid wins. Bids are burned. Nobody extracts a protocol fee from the auction itself. Scarcity is explicit: a handful of new Spaces per day, not an infinite mint.
Stage 2: Issue handles under a Merkle tree.
The Space operator batches handles into a Binary Merkle Trie and commits a 32-byte root to Bitcoin. Each holder gets an off-chain certificate: inclusion plus prior non-existence. That is how you scale to huge numbers of names without writing every username into a block. One May 2026 update described 100 million handles committed under a single 32-byte root.
Stage 3: Resolve off-chain, verify locally.
Records can be published through Certrelay. Apps resolve with Fabric. The client checks a Merkle proof against a Bitcoin-anchored state root. Resolution can look like this:
let fabric = Fabric::new();
let zone = fabric.resolve(“alice@bitcoin”).await?;
Fabric ships across Rust, JavaScript, Go, Swift, Kotlin, and Python. That is the adoption unlock for builders: integrate naming without standing up a custom chain indexer.
Trust Anchor and Trust ID push this further. A Trust ID is a compact commitment derived from Bitcoin headers and Spaces state. Paste or scan it into compatible software and the app can verify protocol state without a central resolver. On macOS, Veritas can generate that anchor; node runners can produce the same ID from the Spaces client.
This is the product pitch in plain English: Bitcoin becomes a certificate authority you can audit.
What the early auction videos got right
When Spaces first hit mainnet, the story was not “another naming token.” It was “names are being bid in sats, right now, on Bitcoin.”
That January 2025 daily recap walked through live auction texture: cheap opens at 100 sats, names rolling into auction, punycode experiments, transfers and registers, and a running total of BTC burned. The tone was practical. You did not need a speech about Web3 identity. You needed a wallet, a node or temporary RPC endpoint, and the willingness to bid.
That energy still matters. Scarce top-level Spaces are a coordination surface. Communities, brands, conferences, open-source projects, and cities can compete in public for @name. Individuals do not have to win @bitcoin to participate. They can get a handle under a Space that already exists.
The later product path made that much easier. Nacho on iOS, Android, and web became a production way to acquire @bitcoin handles. Flat pricing and first-come issuance replaced “compile the client or miss the name.” That is how protocols leave the workshop and enter group chats.
TABConf audiences saw the same idea in builder form: no new blockchain, no Bitcoin consensus change, identity usable for Nostr, wallet naming, and P2P apps. The conference crowd is the right first market. They already run nodes. They already hate custodial identity. They already need handles they can put on a slide.
Spaces vs DNS, ENS, and NIP-05
Comparisons are where skepticism dies or multiplies. Be precise.
Versus DNS: DNS is fast and familiar. It is also political. Registrars, governments, and platform policies can take a name. Spaces treats issuance as a Bitcoin fact plus a proof. After allocation, the design goal is that the community operator cannot quietly revoke you.
Versus ENS: ENS proved that crypto users want names. Most integrations still lean on centralized resolvers. Full verification on Ethereum is heavier than syncing Spaces against a pruned Bitcoin node. Spaces documentation makes that contrast explicit: you can verify the protocol with Bitcoin infrastructure people already run.
Versus NIP-05: NIP-05 made Nostr readable. It also reintroduced DNS. NIP-SPACES is the sovereign alternative: identities anchored to Bitcoin and checked with Merkle proofs instead of an ICANN-shaped trust chain. If Nostr is going to stay credibly neutral, its naming layer cannot depend on the same institutions the protocol was built to route around.
The honest caveat: Spaces is younger than DNS and less ubiquitous than ENS. That is not a reason to wait. Naming systems have winner-take-most dynamics. The names people learn first become the names wallets autocomplete later.
Why this can actually drive adoption
Adoption does not start with a white paper. It starts when a payment instruction becomes a sentence.
Imagine paying robin@bitcoin and letting the wallet choose the rail: on-chain, Lightning, Silent Payments, Ark, or whatever comes next. The handle is the stable interface. The transport can change. That is how Bitcoin becomes usable for people who will never memorize bech32.
The same handle can follow you across:
- Lightning invoices and wallet labels
- Nostr profiles without a DNS host
- P2P apps and encrypted chat
- Conference badges and GitHub bios
- Agents that need a durable key-linked name
Burn auctions add a cultural fit. No premine. No Spaces token. Value that would have gone to a registrar is destroyed instead of captured. That is not marketing copy. It is a distribution rule that makes the system harder to attack through a company that “owns the namespace.”
Subspaces are the scale story. Top-level Spaces stay scarce and expensive enough to be meaningful. Individual identities stay cheap enough to be universal. Once allocated, a subspace can still fall back to on-chain transactions if the holder wants the same settlement path as the parent Space. Off-chain by default, on-chain if necessary. That is how you respect block space and still onboard millions of names.
How to get involved this week
You do not need to understand every Merkle detail to start.
- Read the source of truth at spacesprotocol.org.
- Browse live auctions and registered Spaces on the explorer.
- Get a handle under @bitcoin through Nacho if you want the mobile path.
- Install a Trust Anchor / Veritas flow so your apps verify against Bitcoin instead of a homepage.
- If you run Bitcoin Core, install spaced and space-cli and resolve names yourself.
- If you build apps, add Fabric and resolve name@space in a handful of lines.
- If you run a community, decide whether your people should live under an existing Space or bid for your own.
Quickstart for node runners is documented: sync Bitcoin Core, point spaced at RPC, create a wallet, fund it, then open or bid. That path is for people who want the full cypherpunk loop. Everyone else can start with a handle and a verifier.
Builders should treat this as infrastructure, not a collectible. A name that cannot be recovered by a support desk is a feature. Show the orange verification badge when a handle is sovereign and checked against a trusted anchor. Do not train users to trust a screenshot of a website.
The excitement is justified
Bitcoin does not need another casino overlay. It needs interfaces that feel like tools.
Spaces Protocol is one of the few identity designs that stays inside Bitcoin’s security model: UTXOs, burns, Merkle commitments, local verification, no bridge, no slashing game, no “committee will slashed the operator.” If Bitcoin is still there in twenty years, the name anchored to it can still be checked. That is a rare property in internet identity.
Early auction videos captured the first spark: names going to market in sats, scarce top-levels, a public order book for communities. The current stack captures the second spark: phones, SDKs, Trust IDs, and handles that wallets can actually use.
Claim a name while the namespace is still being learned. Integrate resolution while the APIs are still simple. Run a verifier so you are not renting trust. Then send the first payment that looks like a name instead of a puzzle.
Your name. Your keys. Anchored in Bitcoin.
Start here: https://spacesprotocol.org/
Watch the early auction-era explainer that first pushed this into daily Bitcoin news: https://youtu.be/_CdA3u-74gs
