Eleven Connections, Eight Domain Names: How Bitcoin Finds Itself Without a Server

A new node knows nothing. DNS seeds run by volunteers, an address book written by strangers, eleven outbound slots, and six-byte transaction IDs are the entire reason the Bitcoin network exists at all.

getaddr→addr

A node that has never run before knows nothing and trusts nobody. Within a minute it holds eleven connections, and it learned about every one of them from a domain name maintained by a volunteer it has never met.

People say “the Bitcoin network” the way they say “the electricity grid” — as if there were infrastructure somewhere, with an operator, a control room, a map. There is no map. There is a bootstrap procedure and a set of quotas, and if you read the code you find that the whole thing is held together by the fact that attacking it is more expensive than it looks.

This is the layer nobody writes about, because it has no price chart. It is also the layer where the two most interesting design decisions in Bitcoin live: how a stranger joins, and how a block crosses the planet.

Layer one: eight domain names you have never heard of

Start a fresh node and it faces a circular problem. It needs a peer to learn about peers. Bitcoin’s answer, since 2012, is DNS.

The binary ships with a hardcoded list of seed hostnames — seed.bitcoin.sipa.be and its siblings — each run by a different volunteer. Some are dynamic: the operator runs a crawler that probes the network continuously and publishes the IP addresses of nodes that are actually reachable. Some are static, updated by hand. Query one and you get A records: a handful of IPs that will probably accept an inbound connection on port 8333.

Eleven Connections, Eight Domain Names: How Bitcoin Finds Itself Without a Server
U.S. Air Force photo by Karen Abeyasekara, Public domain, via Wikimedia Commons

The elegance is that DNS is the one naming system on earth that is already everywhere, already cached, already resolvable from a machine with no configuration. The problem is that a DNS answer is unauthenticated. A malicious seed operator — or anyone in a position to intercept the lookup — can hand you a list containing only nodes it controls, and you will happily build your entire view of the world on top of them. That is an eclipse attack, and the seed layer is where it starts.

Which is why the seed is never the only path. A node that has run before keeps a peers.dat file of addresses it has met, and on restart it spends up to 11 seconds trying those before it gives up and asks DNS. If no seed answers within 60 seconds, it falls back to a hardcoded list of IP addresses compiled into the binary at release time. Three mechanisms, deliberately redundant, each one worse than the last.

The history here is a decent reminder of how young this all is. Bitcoin v0.1 did not use DNS seeds at all. It joined an IRC channel — #bitcoin on irc.lfnet.org — announced its IP, and read the channel to find others. That was the primary discovery mechanism for four years, and it was removed in v0.8.2 in 2013. For a while, the peer-to-peer money network bootstrapped through a chat room.

Layer two: an address book written by strangers

Once one connection exists, the seed stops mattering. Peers exchange addr messages — small announcements that say “here is an address I know about” — and over weeks a node accumulates thousands of them. This is the actual decentralised mechanism: the network’s membership is remembered by the network, in ten thousand slightly different copies.

BIP-155 extended this in 2020 with addrv2, which carries Tor v3, I2P and CJDNS addresses natively rather than trying to squeeze them into a format designed for 32-bit IPv4. That matters more than it sounds: a node that can gossip onion addresses can build a peer set that reveals nothing about where it is.

The bootstrap sequence, in the order it happens:

  • Read peers.dat and try known addresses for up to 11 seconds.
  • If that fails, resolve the DNS seeds and connect to what comes back.
  • If no seed answers in 60 seconds, fall back to the hardcoded IP list.
  • Once connected, send getaddr and collect addr messages to refill the book.
  • Keep the good addresses, evict the dead ones, persist the rest.

Layer three: the asymmetry that keeps you honest

Here is the detail I find most revealing. A default node runs 8 outbound full-relay connections, 2 block-relay-only outbound connections, and 1 feeler that connects, handshakes, and immediately disconnects to test whether an address is alive. Inbound capacity is up to 125.

Eleven outbound slots against a hundred and twenty-five inbound is not an accident of defaults. It encodes a trust judgement: a node trusts the peers it chose more than the peers that chose it. Outbound peers were selected by the node’s own address manager, which is why they are allowed to relay transactions and addresses. Block-relay-only peers exist to receive blocks without revealing the node’s mempool — a nod to the fact that transaction announcements leak information about origin.

Eclipse resistance is a budget problem

To isolate a node you must control all ten to eleven of its outbound slots. That is why the outbound count is small and the selection is randomised across network groups: it turns a cheap attack into an expensive one.

Two connections survive restarts

Anchor connections persist across restarts, so a node coming back online reconnects to peers it already trusted instead of being re-seeded from scratch. It is a small feature that closes a large window.

Every node sees a different mempool

There is no global mempool, only per-node views shaped by connection timing, eviction policy and replacement decisions. Two nodes can disagree about which transactions exist and both be correct.

Layer four: how a block crosses the planet in under a second

A new block is the one message where latency has a price. If another miner finds a competing block while yours is still propagating, you may lose the race and the reward with it. That is an orphan, and the orphan rate is a direct function of how long a block takes to reach the rest of the network.

The legacy protocol was stupid in a way that only becomes obvious at scale. A miner sends inv — “I have block X”. Peers that lack it reply getdata. The miner sends the full block, megabytes of transactions that most recipients already have in their mempools. Every hop repeats this. Propagation took ten-plus seconds across the globe.

BIP-152, compact block relay, replaced the payload with a hint. The announcement carries the block header plus 6-byte truncated transaction IDs for every transaction in the block. The recipient matches those against its own mempool, reconstructs the block locally, and requests only the handful of transactions it is missing via blocktxn. A 1 MB block becomes roughly a 25 KB announcement.

The “high-bandwidth” mode goes further: a node may designate a few peers to receive compact blocks before the sender has fully validated them, cutting a round trip out of the critical path. That is a deliberate trade — bandwidth and a little trust for latency — and it is why the best-case block propagation is now under a second to most of the network rather than ten.

Eleven Connections, Eight Domain Names: How Bitcoin Finds Itself Without a Server
U.S. Air Force, Public domain, via Wikimedia Commons
MechanismSinceWhat it carriesWhat breaks it
DNS seeds2012A records for reachable nodesunauthenticated answers, seed capture
addr / addrv2v0.1 / BIP-155addresses of known peerspoisoning, stale entries
inv + getdatav0.1full blocks and transactionsbandwidth, multi-second latency
compact blocksBIP-152header + 6-byte short IDsmempool divergence, missing txs
ErlayBIP-330, not deployedset difference of mempoolsstill a proposal as of 2026

Erlay and the thing it does not fix

Erlay is the proposal I keep hearing described as finished work. It is not. BIP-330 replaces full inventory announcements with set reconciliation: two peers compare their mempool sets and transmit only the difference, which for a node with a large mempool is a small fraction of the current traffic. The design is by Pieter Wuille, Gregory Maxwell and others, and as of 2026 it is still not deployed in a release.

What Erlay would fix is bandwidth. What it would not fix is the property that makes this layer interesting: there is no global state to agree on. Every node’s mempool is a local opinion. Consensus only starts at the block. Erlay makes the gossip cheaper, not the opinions identical.

Eleven Connections, Eight Domain Names: How Bitcoin Finds Itself Without a Server
Jonathon Coombes, Public domain, via Wikimedia Commons

That is the part I wish more people understood about this layer. The network is not a thing that exists and then does consensus. It is a procedure for letting strangers find each other cheaply enough that no single party can stand between them, and every design choice in it — eight seeds, eleven slots, six-byte IDs — is a compromise struck against a specific attack.

“The Bitcoin network” is not infrastructure. It is a habit that ten thousand machines keep.

SourcesBitcoin Developer Guide, P2P Network. BIP-152, Compact Block Relay. BIP-155, addrv2. BIP-330, Erlay. Bitcoin Core default connection counts as of v27.

Satoshi’s first sentence in the whitepaper was not about money. It was about exactly this: a system of electronic transactions “based on cryptographic proof instead of trust, allowing any two willing parties to transact directly with each other without the need for a trusted third party.” Fifteen years later the cryptography gets the attention, and the plumbing that makes two willing parties findable is still eight domain names and a volunteer’s crawler.

(The End)

Blockchain

Nine of Ten Agents Raised Their Own Spending Cap. The Approval Was Real. The Human Wasn't.

2026-11-2 3:14:07

Markets

The Altcoin Season Index Reached 61. The Capital Never Rotated.

2026-10-1 11:49:21

❯
Profile
Cart
Coupons
Search