Most advice on the best hardware for Pi-hole assumes the Raspberry Pi is the cheap option and the only question is which model. That assumption broke in 2026. Memory-driven price rises pushed a 2GB Raspberry Pi 4 to $67.50 and a 2GB Pi 5 to $77.50 before any reseller markup. The $15 Pi Zero 2 W kept its price because it uses older LPDDR2 that Raspberry Pi had in stock. And when we measured Pi-hole itself, the blocklist turned out to be almost irrelevant to RAM: what fills memory is how many DNS queries your home sends in a day.
This guide compares the Pi Zero 2 W, Pi 4, Pi 5 and a cheap x86 mini PC as Pi-hole hardware, and explains the mechanism behind each pick so you can size your own box. We installed Pi-hole on a 512 MB VM (the Zero’s RAM), loaded 2.1 million blocked domains and pushed 570,000 queries through it. Every lab number below comes from Pi-hole Core v6.5 with FTL v6.8 in October 2026, and prices were checked on October 31.
What is the best hardware for Pi-hole?
For most homes, a 2GB Raspberry Pi 5 on wired Ethernet is the default pick now. The price gap to the Pi 4 is only about $10 at MSRP, and Raspberry Pi commits to making the Pi 5 until at least January 2036. Pi-hole itself would run on any of the four options. What separates them is the network port, the power draw and what else you want the box to do, so start from the job:
- Best overall, Raspberry Pi 5 2GB: Gigabit Ethernet, 2.4 W idle, and room for Unbound next to Pi-hole. CanaKit Pi 5 2GB Basic Kit, approx $110 to $120, check the live price.
- Cheapest and lowest power, Pi Zero 2 W: 0.7 W idle and $15 from an approved reseller, but Wi-Fi only unless you add an Ethernet HAT.
- If you can find one near MSRP, Raspberry Pi 4 2GB: Gigabit Ethernet at 1.6 W idle. Raspberry Pi 4 Model B 2GB, approx $95 to $105 on Amazon, check the live price.
- Pi-hole plus other services, Beelink Mini S13 (N150): 2.5GbE, 12 GB RAM and an SSD, so Pi-hole becomes one container among many. Beelink Mini S13, approx $320 to $340, check the live price.
Price is where the old advice misleads most. Every Pi board with 2GB or more costs more at MSRP than it did a year ago. Even the Zero is cheap only from Raspberry Pi’s approved resellers: the one bare Zero 2 W listing on Amazon on October 31 came from a third-party seller asking $85. If a Pi 3 or Pi 4 is already sitting in a drawer, it will run Pi-hole fine, and the sections below explain why.
How we measured what Pi-hole needs
We didn’t have four boards on a bench, so we measured the software instead. Pi-hole’s memory and disk use don’t change much between ARM and x86, which makes a small VM a fair stand-in. Ours ran on Proxmox with 512 MB of RAM (the kernel reports 452 MB usable), two vCPUs, Ubuntu 26.04.1 and the official Pi-hole installer. For the load tests we pinned Pi-hole to one core and drove it with dnsperf from the other.
CPU speed is the part that does not transfer. A Cortex-A53 at 1 GHz is far slower per core than the lab’s x86 core, so read our throughput figures as headroom, not as a Pi benchmark. Idle power comes from Jeff Geerling’s wall-meter readings in his SBC reviews repository, since we had no meter on real boards. Four things got measured, in order:
- Baseline: a fresh install with the default StevenBlack list, 76,737 domains.
- Big blocklists: HaGeZi Pro, OISD Big and HaGeZi Threat Intelligence added on top, 2,116,574 unique domains, with free memory sampled every half second during the rebuild.
- Query load: memory read after 12,000, 50,000, 97,000, 199,000 and 293,000 queries since a clean restart, plus a steady 200 queries per second for a minute to read CPU time.
- Add-ons: Unbound as a local recursive resolver, using the configuration from the Pi-hole documentation.
We kept the raw logs and the five scripts that produced every number, and the commands shown below are the ones we ran. Only the power column and the prices come from outside sources.
What Pi-hole actually uses on a 512 MB box
Pi-hole is one process. Since version 6, pihole-FTL answers DNS, serves the web dashboard on ports 80 and 443 and writes the query database. There is no lighttpd or PHP stack any more, and our install had neither package. That single process is what we measured:
| Measurement (512 MB VM) | Result |
|---|---|
| FTL memory, default list (76,737 domains) | 11.3 MB |
| FTL memory, 2,116,574 unique domains | 11.4 MB |
| gravity.db, default list vs big lists | 4.5 MB vs 146 MB |
| Gravity rebuild with big lists | 27.3 s, 40 MB peak, never below 225 MB available |
| FTL restart to first answer, big lists | 2.8 s |
| FTL memory after 293,318 queries | 86.1 MB |
| FTL memory after 569,766 queries | 156.2 MB, 129 MB still available |
| Steady 200 queries/s for 60 s, fresh restart | 4.3% of one core, 0.28 ms average latency |
| One-core ceiling, cached answers | 9,308 queries/s |
| Unbound resident memory | 19.6 MB |
Two rows explain the whole buying decision. Growing the blocklist 28 times moved FTL’s memory by about 0.02 MB, while 570,000 queries moved it by 145 MB. Blocklists cost disk, queries cost RAM, and CPU barely registers at home-network rates. Once you know why, you can size any box from your own dashboard.
The one CPU exception we saw: a 200 queries per second run made straight after a 500,000-query burst used about 44% of a core for 20 seconds, most likely while FTL was still writing that burst to disk, though we did not isolate the cause.
Why blocklist size barely moves RAM
Pi-hole keeps blocked domains in an SQLite database, /etc/pihole/gravity.db, and looks them up there instead of loading the list into memory. The kernel caches the hot pages of that file. Cache is memory the kernel hands back under pressure, though, so it never pushed our 512 MB VM toward the out-of-memory killer. You can check how many entries your own gravity table holds:
sudo pihole-FTL sqlite3 /etc/pihole/gravity.db "select count(*) from gravity;"With the three extra lists loaded, the table held 2.38 million rows, or 2.1 million unique domains once duplicates across lists are removed:
2378819Big lists cost you storage instead. The database grew from 4.5 MB to 146 MB, and Pi-hole keeps the previous build as gravity_old.db after every update, so plan for two copies. On a 32 GB card that is nothing, and it sits far below the 2 GB of free space the Pi-hole prerequisites ask for. It’s also 146 MB rewritten by the weekly gravity update, which matters on a cheap SD card. The installer schedules that update at a random time between 03:00 and 05:00 on Sunday (ours landed at 03:55), and /etc/cron.d/pihole shows yours.
Why query volume is what fills memory
FTL holds the last 24 hours of queries in RAM so the dashboard and the API can answer instantly. That window is a setting you can read:
sudo pihole-FTL --config | grep -iE 'maxHistory|maxlogage|maxDBdays|DBinterval'The 86400 is seconds, one day of history in memory. The database keeps 91 days on disk, and FTL flushes new queries to it every 60 seconds:
database.maxDBdays = 91
database.DBinterval = 60
webserver.api.maxHistory = 86400In our runs each query held in that window cost roughly 260 bytes. Memory went from 11.5 MB after a flush to 86.1 MB after 293,318 queries, and after the first 12,000 queries the growth was close to linear at every step we sampled. A restart does not reset it either: after 569,766 queries FTL logged Imported 569766 queries from the on-disk database and came back at 156 MB, because it reloads the last 24 hours from disk.
Treat that figure as a floor. Our load came from one client asking for 15 names over and over, then 2,000, and a real home has many clients and far more distinct domains, each stored once.
So the sizing rule is simple. Open the dashboard, read the total queries for the last 24 hours, and multiply by about 260 bytes, then add headroom. A home that sends 100,000 queries a day needs roughly 26 MB for Pi-hole’s query history by that rule. Any of these boards covers that many times over. The Zero has the least slack, and a real board’s usable memory depends on its firmware and OS settings, so leave it more margin than our VM’s 452 MB suggests.
What 512 MB actually ran out of
Pi-hole never came close to the limit, but the operating system did. On first boot, cloud-init upgraded the kernel and rebuilt the initramfs. The kernel log shows the OOM killer stopping zstd three times with 192 to 236 MB of anonymous memory in use. While that upgrade was still running, the Pi-hole installer stopped at Error: Unable to install Pi-hole dependency package., and a second run after the upgrade finished went through cleanly.
On a 512 MB Zero, then, finish OS updates and reboot before you install Pi-hole, and keep big upgrades away from the Sunday gravity run. Raspberry Pi OS may package its kernel differently from Ubuntu. Still, any heavy package job is the moment a 512 MB board gets tight, not Pi-hole itself.
Error: “Rate-limiting 127.0.0.1 for at least 57 seconds”
Our first load test returned REFUSED for every one of 414,950 queries. The cause is a default to rule out before you blame the hardware: Pi-hole rate-limits each client to 1,000 queries per 60 seconds, then refuses it until the window clears. The log said so plainly:
sudo grep -iE 'rate.?limit' /var/log/pihole/FTL.log | tail -3The log is readable only by the pihole user and root, hence the sudo. Each line names the client, so a misbehaving device on your network is easy to spot:
2026-10-31 06:32:18.436 UTC [33718M] INFO: Rate-limiting 127.0.0.1 for at least 57 seconds
2026-10-31 06:33:15.065 UTC [33718/T33728] INFO: Still rate-limiting 127.0.0.1 as it made additional 857874 queries
2026-10-31 06:34:15.072 UTC [33718/T33728] INFO: Ending rate-limitation of 127.0.0.1The cut-off is exact: a later 10,000-query burst from one client got 1,000 normal answers and 9,000 REFUSED. For a real home, this limit also gives a sense of scale. A device at the ceiling sends about 17 queries a second. Ten devices at that rate would still sit under the 200 queries per second that cost 4.3% of one x86 core in our test. If your router forwards every client’s DNS through itself, Pi-hole sees one client and the limit can bite. Raise dns.rateLimit.count in that case, or have DHCP hand out the Pi-hole address directly. We turned the limit off only for the benchmark and set it back to 1000 afterwards.
How the four options compare
Pi-hole’s own needs fit in any of these, so the columns that decide the purchase are the network port, idle power and real price:
| Option | CPU | RAM | Wired network | Idle power | Official price | Amazon, Oct 31 |
|---|---|---|---|---|---|---|
| Pi Zero 2 W | 4x Cortex-A53, 1 GHz | 512 MB | None (2.4 GHz Wi-Fi) | 0.7 W | $15 | Avoid (approx $85, third party) |
| Pi 4 Model B 2GB | 4x Cortex-A72, 1.8 GHz | 2 GB | Gigabit | 1.6 W | $67.50 | approx $95 to $105 |
| Pi 5 2GB | 4x Cortex-A76, 2.4 GHz | 2 GB | Gigabit | 2.4 W | $77.50 | approx $110 to $120 (kit) |
| Beelink Mini S13 | Intel N150, up to 3.6 GHz | 12 GB | 2.5GbE | about 9 W (N150 class) | n/a | approx $320 to $340 |
| Used tiny PC (M720q, 800 G4) | Intel 8th gen | 8 to 16 GB | Gigabit | 11 to 14 W | n/a | approx $180 to $250 used (Newegg and dealers, Oct 20) |
Idle power is where the long-run cost hides. Over a year of 24/7 running, 0.7 W is about 6 kWh, 2.4 W is about 21 kWh and 9.3 W is about 81 kWh. Multiply by your own tariff before you decide a mini PC is cheaper than a Pi. The N150 figure is Jeff Geerling’s reading of a GMKtec G3 Plus with the same chip, and he ran that box’s benchmarks in its High Performance BIOS profile, so the idle figure may run high; CNX Software lists N100 mini PCs at a typical 7.5 to 10 W. The tiny PC range comes from ServeTheHome, so treat these as class averages rather than the exact box. The Pi 4 reading does not state the board’s RAM size.
Why the Raspberry Pi 5 2GB is the default pick
The Pi 5 wins on the boring things that keep a DNS server up. It has a Gigabit Ethernet port, a proper 5V USB-C supply and a production commitment that runs to at least January 2036. The 2GB board is the safe size: even after 570,000 queries FTL used 160 MB, and Unbound adds about 20 MB on top. Paying for 4GB or 8GB buys nothing for this job.
The 1GB Pi 5 would also be enough, and its $45 official price was left unchanged in the October increase, but on October 31 Amazon only had it inside a third-party kit at about $94, so look for it at an approved reseller.
A smaller board also draws less power. Jeff Geerling measured the 2GB Pi 5, which uses a newer D0 chip revision, at 2.4 W idle against 3.3 W for a 4GB board with the older C1 chip. Its extra CPU over a Pi 4 doesn’t help Pi-hole at home. It does mean a gravity update with millions of domains finishes quickly and the dashboard stays responsive while it runs.
Skip it if you already own a Pi 4 or Pi 3, because Pi-hole will not run noticeably better on the new board. Skip the bare board too unless you have a USB-C supply rated for 5V at 3A or more. Raspberry Pi recommends its 27W supply for the Pi 5, and an underpowered phone charger causes the random reboots people blame on Pi-hole. On October 31 the CanaKit Raspberry Pi 5 Basic Kit (2GB, no SD card) sold for approx $110 to $120 and the bare 4GB board for about $130. Check the live price and the kit contents before you buy.
Why the Pi Zero 2 W is enough, with one catch
The Zero 2 W has exactly the 512 MB that Pi-hole’s documentation lists as the minimum. Our 512 MB VM still had 129 MB available after holding 570,000 queries in memory, so RAM is not the problem unless your home sends well over half a million DNS queries a day. At 0.7 W idle it’s also the cheapest board to leave running. Raspberry Pi says it does not expect the Zero’s $15 price to rise, because the board uses older LPDDR2 of which it holds substantial inventory.
The catch is the network. The board has no Ethernet port, only 2.4 GHz 802.11b/g/n Wi-Fi, so every DNS answer in your house travels over the noisiest band in it. A dropped Wi-Fi link takes name resolution down for every device, which is a worse failure than a slow dashboard. Waveshare’s Ethernet/USB HUB HAT (approx $19, check the live price) adds a 10/100 RTL8152B port, which is plenty for DNS. It mounts on the 40-pin header, though, and the Zero 2 W ships without one, so plan to solder a header on or buy a board that has it. The HAT’s Ethernet chip and USB hub also draw power of their own, so a wired Zero idles above the 0.7 W measured on the bare board.
Buy the Zero 2 W from one of the approved resellers on Raspberry Pi’s product page, not from Amazon. There, the only bare board on October 31 was $85 from a third-party seller, and the CanaKit Zero kits were out of stock. Skip the Zero entirely if you want Unbound, a second service or a dashboard that loads quickly with months of history. A 1 GHz Cortex-A53 has far less headroom than our x86 test core.
When a Raspberry Pi 4 still makes sense
A Pi 4 is the best Pi-hole board you might already own. Its quad Cortex-A72 at 1.8 GHz, Gigabit Ethernet and 1.6 W idle draw cover everything Pi-hole and Unbound need, and it idles lower than a Pi 5. As a new purchase it has lost its point, though. The 2GB model’s official price is now $67.50 against $77.50 for a 2GB Pi 5, and Amazon’s board-only listing was about $100 on October 31.
Buy one new only if you find it at or near the official price from an approved reseller, or if you want a second, identical board for a redundant Pi-hole pair. It needs a 5V/3A USB-C supply. The 2GB Raspberry Pi 4 Model B listing (approx $95 to $105, check the live price) showed limited stock when we checked. Skip it if the Pi 5 2GB kit is within $15, because you’ll get a newer board with a longer production commitment.
When a mini PC is the better Pi-hole box
A mini PC is overkill for Pi-hole alone and the right call when Pi-hole is one of several services. The Beelink Mini S13 pairs an Intel N150 with 12 GB of LPDDR5, a 512 GB SSD and a 2.5GbE port. It can run Pi-hole in Docker or an LXC container next to Home Assistant, a reverse proxy and a few VMs. The SSD also takes the query database’s minute-by-minute writes without the wear worries of an SD card.
You pay for that headroom in power and price. An N150 box idles around 9 W, roughly four times a Pi 5. The Beelink Mini S13 listed at approx $320 to $340 on October 31 (check the live price), and the cheapest new N150 boxes we found on Amazon still started around $230 with only Gigabit Ethernet. Beelink’s own store no longer lists the S13, so buy it from the Beelink storefront on Amazon.
If Pi-hole is the main job and you want x86, a used Lenovo M720q or HP EliteDesk 800 G4 Mini at $180 to $250 (October 20 prices) does the same work. Our used tiny PC guide covers which models to buy, and the mini PC picks for Proxmox go further up the range. Skip the mini PC if this box will only ever run Pi-hole. You’d pay three times the price of a Pi 5 kit and four times the electricity for capacity our lab says Pi-hole never touches, a trade-off our Raspberry Pi 5 vs N150 mini PC comparison covers in depth.
What matters when you choose Pi-hole hardware
Our measurements reduce the decision to a short list of things that actually fail on a home DNS server. In order of how often they cause trouble:
- Wired Ethernet: DNS is in the path of every connection, so a flaky Wi-Fi link breaks the whole house. Pick a board with a port, or add one to the Zero.
- Storage that survives writes: FTL writes the query log every 60 seconds and keeps 91 days, and our 569,768 logged queries filled a 35 MB database. An endurance-rated card or an SSD outlives a bargain card, and our microSD card guide for Raspberry Pi lists the ones rated for continuous writes.
- A correct power supply: 5V/2.5A micro USB for the Zero 2 W, 5V/3A USB-C for the Pi 4, and the 27W USB-C supply Raspberry Pi recommends for the Pi 5.
- RAM sized from your query count: 24-hour query total times about 260 bytes, plus about 12 MB for FTL and 20 MB if you add Unbound.
- Two boxes, not one big one: two cheap Pi-holes handed out as primary and secondary DNS keep the network working during updates and reboots, which one powerful box cannot do.
Once the hardware arrives, the install is the same on all of them. Our guide to installing Pi-hole on Debian covers Raspberry Pi OS, which is Debian underneath. Running Pi-hole in Docker is the cleaner route on a mini PC that already runs other containers. If Unbound is part of the plan, expect slow cold lookups: ours timed out on its very first query right after starting, then most new domains took 345 to 872 ms on their first lookup and 0 ms once cached, so the first page loads after a reboot feel slower on any of these boards.
Where the “just use a Raspberry Pi” advice breaks down
The old advice was right about Pi-hole and wrong about the reasons. Pi-hole is still tiny: about 12 MB to start, roughly 260 bytes per query in its 24-hour window, a gravity database that lives on disk, and a few percent of one core at loads a home won’t reach. Everything around it changed. A Pi is no longer automatically the cheapest box, and the Zero is cheap only away from Amazon. The failure you’re most likely to hit is a Wi-Fi drop, a worn-out SD card or a weak power supply rather than a slow CPU.
So keep this model: size RAM from your query count, size storage from your blocklists and log retention, pick the network port first, and only then compare boards. Under that model a 2GB Pi 5 on Ethernet is the safe default and a wired Zero 2 W is the frugal one. A Pi 4 you already own costs nothing, and a mini PC earns its power bill only when Pi-hole shares it with other services.
