Most guides to a Raspberry Pi ADS-B flight tracker assume the USB dongle decides how many aircraft you see, and it rarely does. Every RTL-SDR stick on the shortlist decodes 1090 MHz well enough. What separates a feeder that hears aircraft near the horizon from one that only sees the approach overhead is antenna height, coax loss and whether a strong transmitter nearby is swamping the tuner. So the money goes on the radio front end first, the dongle second and the Pi last.
This guide explains the parts in that order, then the software that turns them into a feeder: wiedehopf’s readsb decoder, the tar1090 map, the ADSB.lol feed client and FlightAware’s PiAware, all reading one decoder. We ran the software side in November 2026 against readsb 3.16.21 on Debian 13 arm64, the base of current Raspberry Pi OS, on a Pi-class cloud VM with no radio attached. Every command and log line below comes from that box. The decoding numbers do not, and the hardware specs come from the makers’ datasheets rather than our bench.
What a Raspberry Pi ADS-B flight tracker needs
You need four things that touch the signal and two that do not. We would buy them in this order, because each one fixes a bigger loss than the next:
- Best antenna for most homes: the ADSBexchange 5.5 dBi 1090/978 MHz antenna. It is a tuned outdoor whip with an N-female connector, and getting it above the roofline is worth more than any other upgrade on this page.
- Best filter and LNA: the Nooelec SAWbird+ ADS-B. It puts a SAW filter and a 34 dB low-noise amplifier in one box powered over USB, so it works with dongles that have no bias tee.
- Best dongle you can buy on Amazon today: the ADSBexchange Orange. It has an R860 tuner, a 0.5 ppm TCXO and a built-in amplifier, and it runs on the stock Debian rtl-sdr driver with no extra install.
- Best Pi for the job: a Raspberry Pi 4 Model B with 2 GB. The feeder processes used about 45 MB of RAM in our lab, and wiedehopf, who maintains readsb, names the Pi 4 as his pick and calls the Pi 5 overkill.
The two parts that do not touch the signal are a power supply and a microSD card. Use the official supply for whichever Pi you pick, which means 5 V at 3 A minimum for the Pi 4 and 5 V at 5 A for the Pi 5. Pick a high-endurance card too, because it holds the OS and the system logs on a box that never switches off, and our microSD card guide covers which ones survive that. You also need one N-male to SMA-male coax jumper from the antenna to the filter. Prices below were checked against Amazon’s own catalogue on 11 November 2026 and they move often, so check the live listing before you order.

The antenna sold for about $45 (check the live price), in stock and sold by ADSBexchange itself. It comes without a cable, which is the right call, because the length you need depends on where the mast is. Skip it if you can only mount indoors behind a window. A cheaper indoor whip loses little there, since the glass and walls already cost you more than the antenna’s gain buys back.

The SAWbird+ ADS-B was about $95 (check the live price) and in stock from Nooelec. Its datasheet gives 34 dB of gain, a 0.8 dB noise figure and an 8 MHz passband around 1090 MHz. It takes power from micro-USB (300 mA), a bias tee (140 mA) or a DC adapter, one source at a time. Skip it if your antenna sits on a short run in a rural area with no strong transmitters nearby. FlightAware’s Pro Stick page says filtering is generally not recommended for users in rural environments, and 34 dB of extra gain on a short cable can push a dongle into overload.

The Orange stick was about $48 (check the live price), in stock and sold by ADS-B Exchange. Its maker page says plainly that it has no 1090 MHz filter and recommends the filtered blue stick for standard 1090 MHz use. That blue stick’s Amazon listing was dead when we checked, so the Orange plus the SAWbird+ is the Amazon route to the same result. Skip it if you want a single-box answer and can order direct. FlightAware’s Pro Stick Plus puts a 1,075 to 1,105 MHz filter and a 19 dB amplifier inside the stick, but its Amazon listing was unavailable, so it is a FlightAware store purchase.

The Pi 4 2 GB listing we checked was about $93 from a reseller with three units left (check the live price). That is well above Raspberry Pi’s list price, so look at an approved reseller before you pay it. Skip buying a Pi at all if one is already in a drawer. A Pi 3 runs readsb too, though wiedehopf finds it less reliable, and a Pi 5 works but brings a 27 W supply and a cooling question to a job that mostly idles. If you are still choosing a board, our Raspberry Pi 5 kits and alternatives roundup compares them, and the Pi 5 case guide covers enclosures built to run all day.
How a 1090 MHz reply becomes a dot on the map
An ADS-B feeder is one decoder with several consumers bolted onto its output, and once you see it that way most setup problems explain themselves. The aircraft does the hard part. Its transponder broadcasts its own position, altitude and identity on 1090 MHz without being asked, unencrypted, and your job is to hear those short bursts and hand them out. In order:
- The antenna picks up the 1090 MHz burst along with everything else in the band. Inside the SAWbird+, a low-noise amplifier boosts it first and a SAW filter then cuts everything outside an 8 MHz window, and the datasheet shows two of those amplifier and filter stages in a row.
- The RTL-SDR dongle digitises that slice of spectrum and hands raw IQ samples to the Pi over USB.
- readsb opens the dongle, demodulates the Mode S messages and keeps the state of every aircraft it hears. It writes that state as JSON to
/run/readsband serves the raw messages in Beast format on TCP port 30005. - tar1090 draws the JSON on a map through lighttpd, while the ADSB.lol client and PiAware each connect to port 30005 and forward the messages to their own servers.
The diagram shows the consequence that matters most in practice. Only readsb ever opens the USB device, so you can feed two, three or five aggregators from one dongle without them fighting over it. It also explains why installing a second decoder such as dump1090-fa next to readsb breaks things rather than adding redundancy.

Only two arrows leave your network in the diagram. One is TCP to feed.adsb.lol on ports 30004 and 31090, the other a TLS session to FlightAware on port 1200. If you filter outbound traffic, allow two more: the ADSB.lol config lists feed2.adsb.lol on port 1337 as a fallback, and a 2018 FlightAware forum post quoting PiAware’s MLAT developer says its MLAT client sends UDP to a port between 4999 and 9999 once it has traffic to time, which our silent lab never triggered. Nothing listens on the internet side, so a feeder behind ordinary home NAT needs no port forwarding at all.
Why the filter and coax matter more than the dongle
Cheap RTL-SDR tuners share one weakness. A strong signal from a nearby transmitter, such as a cell tower a few hundred metres away, overloads the front end and the weak, distant aircraft disappear under it. A SAW filter in front of the dongle stops that signal reaching the tuner at all, which is why a filtered setup can out-range an unfiltered one built on a better stick. The table compares the dongles you will see recommended, with the stock state we found.
| Dongle | 1090 MHz filter | Onboard amp | Bias tee | Stock Debian driver | Where to buy (Nov 2026) |
|---|---|---|---|---|---|
| ADSBexchange Orange | No | Yes | Not claimed | Yes (R860) | Amazon, in stock |
| FlightAware Pro Stick Plus | Yes, 1,075 to 1,105 MHz | 19 dB, 0.4 dB NF | Not listed | Yes (R820T2) | FlightAware store only |
| RTL-SDR Blog V3 | No | No | Yes | Yes | Amazon, stock not confirmed |
| RTL-SDR Blog V4 / V4L | No | No | Yes, 4.5 V | Not on bookworm; trixie’s 2.0.2 adds it (untested here) | V4 end of life, V4L direct only |
| Nooelec NESDR SMArt v5 | No | No | No | Yes | Amazon, in stock |
People usually miss the driver column. The RTL-SDR Blog V4 uses an R828D tuner, and wiedehopf’s install notes warn that the Debian and Raspberry Pi OS packages do not drive it, which was true of bookworm’s rtl-sdr 0.6.0. Trixie ships rtl-sdr 2.0.2, whose source detects the V4 and carries its tuner code, and readsb’s installer builds against that library. We had no V4 to prove it decodes, so on bookworm treat the V4 as needing the blog’s own driver, and on trixie test it before you mount anything. The Orange, the Pro Stick Plus and the Nooelec all use R820T2 or R860 tuners that the stock librtlsdr0 package has handled for years. For a wider look at these sticks beyond ADS-B, see our SDR roundup for Linux.
Coax is the other quiet loss. Working from Times Microwave’s published attenuation formula, 10 m of LMR-240 loses about 2.7 dB at 1090 MHz and 10 m of LMR-400 about 1.4 dB. wiedehopf’s own shopping list says LMR-240 is fine up to about 8 m and moves to LMR-400 for longer runs. Every 3 dB lost is half the signal gone before it reaches the amplifier, so the SAWbird+ belongs at the antenna end of a long run, not next to the Pi. With a 1 m jumper, put it wherever is convenient and lower the dongle gain instead.
How we tested the software side
We had no RTL-SDR dongle on the lab cluster, so we split the work. The hardware advice above comes from the makers’ datasheets and listings, logged with sources. The software ran for real on a 2 vCPU, 8 GB arm64 VM (Ampere Neoverse-N1) with Debian 13 trixie, the same Debian base and CPU architecture as a Pi 4 or Pi 5 on current Raspberry Pi OS. The lab user was gedion and the hostname adsb-feeder. Every installer below ran to completion and both aggregators accepted the connection. What we could not test is reception, because no aircraft were decoded, so the message counters you see here read zero where yours will climb.
Without a dongle, readsb exits immediately. After capturing that failure we switched its receiver line to --device-type none, which keeps the decoder running network-only with all of its ports open. You won’t need that workaround on real hardware, where the installer’s default config is what you want.
How to install readsb on Raspberry Pi OS
Flash Raspberry Pi OS Lite (the trixie release) with SSH enabled and log in. Install the rtl-sdr tools before you plug the dongle in, or unplug and replug it afterwards, because Debian’s udev rule only gives the plugdev group access to a stick that appears after the rule exists. Then check that librtlsdr can see the stick, since every later failure looks the same from readsb’s side.
sudo apt-get update
sudo apt-get install -y rtl-sdr
rtl_test -t
With a stick attached, rtl_test names the device and its tuner. Our VM had no radio, so it printed the line you will also get when the dongle is unplugged, dead or claimed by the DVB-T kernel driver.
No supported devices found.
Now run wiedehopf’s installer. It compiles readsb from source for the Pi’s CPU, creates a readsb system user, writes /etc/default/readsb and enables readsb.service. It then installs tar1090 and lighttpd on its own, so one command gives you the decoder and the map.
sudo bash -c "$(wget -O - https://github.com/wiedehopf/adsb-scripts/raw/master/readsb-install.sh)"
The build took a few minutes on our two cores. The nested tar1090 step prints All done! Webinterface available at http://10.0.1.50/tar1090, and with a working dongle that is the last thing you see. The wiki follows the install with a reboot on a Pi that has never run rtl-sdr software, so the udev rule and permissions are in place before readsb first opens the stick.
sudo reboot
We rebooted the lab box once everything in this guide was installed, and readsb, tar1090, lighttpd and both feeders came back on their own. If the dongle is missing, a readsb ERROR block follows that success line, and the journal says why.
journalctl -u readsb -n 9 --no-pager
readsb logs its network ports, fails to open the radio and exits. systemd then restarts it every 15 seconds until you fix the hardware.

On a Pi with a working dongle you get the same port lines without the FATAL, and the aircraft count starts to climb. Two settings matter before you leave readsb alone. Your location lets readsb decode surface positions and draw range outlines, and it is where the map centres. Use your antenna’s coordinates; ours are an example near Heathrow.
sudo readsb-set-location 51.4700 -0.4543
Gain is the trade-off between hearing distant aircraft and overloading on close ones. The installer starts at auto, readsb’s own autogain, and with an amplified stick plus a 34 dB LNA we would leave it there. Manual gain is optional: wiedehopf’s gain guide aims for about 5 percent of messages arriving as strong signals (up to 10 near an airport) and gives a command to read that figure from readsb’s stats. We pinned the install wiki’s example value only to show what the helper writes.
sudo readsb-gain 43.9
Both helpers simply rewrite /etc/default/readsb, which makes the result easy to check. The gain helper also tries to push the new value into the running decoder through /run/readsb/setGain. On our dongle-less VM readsb was not running, so that write failed with a harmless tee error while the file still changed. To go back to autogain, run sudo readsb-gain auto; on the lab box it rewrote the line to --gain auto.

Read the four option lines as the whole configuration. RECEIVER_OPTIONS is the dongle (index, type, gain, frequency correction), DECODER_OPTIONS carries your position, NET_OPTIONS defines the ports the feeders use and JSON_OPTIONS controls the map data. Restart readsb after any hand edit with sudo systemctl restart readsb.
What tar1090 shows and which ports it needs
tar1090 is the map on port 80 at http://<pi-address>/tar1090/, and it reads nothing but the JSON readsb writes. Before opening a browser, confirm that readsb’s ports are listening and that the map’s data endpoint answers.
ss -tln | grep -E ":(80|8504|3000[1-5]|30104) " | grep -v "\[::\]"
curl -s http://localhost/tar1090/data/aircraft.json
Eight listeners is a healthy result. Port 30005 is the Beast output every feeder reads, and 30004 and 30104 accept Beast input, with MLAT results coming back in on 30104. Ports 30001 to 30003 carry raw and SBS formats for older tools, and lighttpd serves tar1090 on 80 and 8504.

Our aircraft.json reports "messages" : 0 and an empty list because nothing was on the air for it. On your Pi, run the same curl a minute after boot. A growing message count with an empty aircraft list means the dongle works but the antenna hears nothing useful, which points at the coax or the mounting rather than the software.
The map itself opened centred on the location we set, with the receiver drawn as a black dot. Two parts of the screen tell you whether the feeder is healthy. The Messages counter (1) at the top of the sidebar reads n/a when readsb receives nothing and a rate per second once it decodes, and the Settings cog (2) holds the display options.

- 1Messages counter
- 2Settings cog
Opening the Settings cog shows how much of the display you can change without touching a file, from units and label styles to the altitude chart.

Those choices live in the browser rather than on the Pi, so each person who opens the map gets their own. Keep port 80 on your LAN. We saw no login prompt on tar1090, and nothing about feeding needs it reachable from outside.
How to feed ADSB.lol from the same Pi
ADSB.lol is a community aggregator that publishes its data openly. Its feed client is a second, network-only readsb that reads your port 30005 and forwards a reduced Beast stream, plus an mlat-client for multilateration. The documented one-liner fetches the script from adsb.lol/feed.sh, but in our test that URL answered curl and wget with an HTTP 403 bot-verification page from two different networks. The project’s GitHub README documents the same script at its raw GitHub URL, and that copy downloaded cleanly.
curl -fsL -o /tmp/adsblol.sh https://raw.githubusercontent.com/adsblol/feed/master/install.sh
sudo bash /tmp/adsblol.sh
The script is interactive, so run it from a real SSH terminal. It asks four questions in whiptail dialogs: a feeder name, which appears on the MLAT map, then the antenna’s latitude, longitude and altitude. Accurate coordinates matter here more than anywhere else, because MLAT solves aircraft positions from arrival times at several receivers and a wrong receiver position spoils that maths for everyone. The script builds mlat-client in a Python venv, compiles its own readsb copy as feed-adsblol and enables two services. Check that they are up and connected.
systemctl is-active readsb adsblol-feed adsblol-mlat piaware
journalctl -u adsblol-feed -n 3 --no-pager
ss -tn | grep -E ":(30004|31090|1200) *$"
We captured this after PiAware (next section) was also running, so the socket list shows all three outbound sessions at once. Look for BeastReduce TCP output: Connection established: feed.adsb.lol in the journal and established connections to port 30004 (data) and 31090 (MLAT) in the socket list.

ADSB.lol also lets you ask its servers what they see from your IP. That is the check that proves the feed arrived rather than merely left.
curl -s https://api.adsb.lol/0/me | python3 -m json.tool
Our feeder appeared under both beast and mlat with zero positions, which is exactly right for a receiver that hears nothing. The adsblol_my_url field is your personal map of what your station contributes (we blanked ours), and global shows the size of the network you joined, about 6,600 Beast feeders when we checked.

The answers you gave the dialogs end up in /etc/default/adsblol. ADSB.lol’s documented way to change them is to run the installer again. For a quick rename, changing the USER= line and restarting both services also works, which is what we did on the lab box.
sudo sed -i "s/^USER=.*/USER=\"gedion-lhr\"/" /etc/default/adsblol
sudo systemctl restart adsblol-mlat adsblol-feed
The new name showed up in the mlat block of the same API call within a minute.
How to feed FlightAware with PiAware
FlightAware rewards feeders with a free Enterprise account, and PiAware is its uploader. FlightAware publishes a trixie arm64 repository, so the packaged route works on current Raspberry Pi OS. Install the repository package that FlightAware’s instructions name, then PiAware itself.
wget https://www.flightaware.com/adsb/piaware/files/packages/pool/piaware/f/flightaware-apt-repository/flightaware-apt-repository_1.3_all.deb #https://www.flightaware.com/adsb/piaware/install
sudo dpkg -i flightaware-apt-repository_1.3_all.deb
sudo apt update
sudo apt install -y piaware
Skip the dump1090-fa step on FlightAware’s page. That is FlightAware’s own decoder, and with readsb already owning the dongle a second decoder would only fight it for the USB device. PiAware found readsb on port 30005 by itself in our run, but we would still set the source explicitly so a later package update cannot change its guess.
sudo piaware-config receiver-type other
sudo piaware-config receiver-host 127.0.0.1
sudo piaware-config receiver-port 30005
sudo systemctl restart piaware
Each setting lands in /etc/piaware.conf, and the tool prints the line it changed.
Set receiver-type to other in /etc/piaware.conf:7
Set receiver-host to 127.0.0.1 in /etc/piaware.conf:8
Set receiver-port to 30005 in /etc/piaware.conf:9
Then ask PiAware to report on itself. Two lines matter in the output: faup1090 is connected to the ADS-B receiver means it reached readsb, and piaware is connected to FlightAware means it reached the server.
piaware-status
The MLAT client stays stopped until there is traffic to time, which is why fa-mlat-client shows as not running on our silent VM.

PiAware logs in as guest until you claim it. Its journal shows the session coming up and the feeder ID it was given.
Nov 11 11:43:37 adsb-feeder piaware[6841]: Connecting to FlightAware adept server at piaware.flightaware.com/1200
Nov 11 11:43:37 adsb-feeder piaware[6841]: Connection with adept server at piaware.flightaware.com/1200 established
Nov 11 11:43:37 adsb-feeder piaware[6841]: TLS handshake with adept server at piaware.flightaware.com/1200 completed
Nov 11 11:43:37 adsb-feeder piaware[6841]: FlightAware server certificate validated
Nov 11 11:43:37 adsb-feeder piaware[6841]: encrypted session established with FlightAware
Nov 11 11:43:38 adsb-feeder piaware[6841]: logged in to FlightAware as user guest
Nov 11 11:43:38 adsb-feeder piaware[6841]: my feeder ID is xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
Nov 11 11:43:39 adsb-feeder piaware[6841]: ADS-B data program 'readsb' is listening on port 30005, so far so good
To link the station to your FlightAware account, read the ID from /var/cache/piaware/feeder_id and open https://www.flightaware.com/adsb/piaware/claim/ followed by that ID while signed in, as FlightAware’s install page describes. We did not claim the lab feeder, since a station with no antenna has nothing to contribute.
How much of the Pi the feeder stack uses
Less than most people expect. With readsb, tar1090, both ADSB.lol services and PiAware running, the whole VM used 434 MB of RAM, and the feeder processes themselves add up to about 45 MB resident.
ps -eo rss,comm --sort=-rss | grep -E "piaware|mlat|feed-adsblol|readsb|lighttpd|faup"
free -m | head -2
PiAware’s Tcl runtime is the largest at about 19 MB, the Python mlat-client comes next at 14 MB, and readsb itself stays under 4 MB.

Two caveats keep this honest. We measured with zero aircraft, so treat these figures as a floor rather than what a busy airport approach will cost. The root filesystem also showed 2.7 GB used after the build tools and both source trees landed, so a 16 GB card leaves comfortable room. A 2 GB Pi 4 has plenty of headroom. We have not run this stack on a Pi Zero 2 W and would not promise it, even though FlightAware’s own entry-level FlightFeeder is built on the older Zero W.
What the first-boot errors mean
Each message below came up in our run. They look alarming, but each one has a single cause.
FATAL: rtlsdr: no supported devices found.
readsb could not open a dongle, and the installer reports it as ERROR: readsb service didn't start. common issues: SDR not plugged in. Check rtl_test -t first. If it finds nothing with the stick plugged in, try another USB port and power supply. If it finds the stick but says Please fix the device permissions, replug it or reboot so the udev rule applies. If it complains that the kernel driver is active, the DVB-T driver has claimed it. Debian builds librtlsdr to detach that driver by itself, which is why the trixie package ships no blacklist file, so treat this blacklist from wiedehopf’s wiki as the fallback when detaching fails, followed by a reboot.
echo -e 'blacklist rtl2832\nblacklist dvb_usb_rtl28xxu\nblacklist rtl8192cu\nblacklist rtl8xxxu\n' | sudo tee /etc/modprobe.d/blacklist-rtl-sdr.conf
Our cloud kernel loaded no DVB modules, so we could not reproduce the conflict itself. We only confirmed that nothing in /etc/modprobe.d blocks those modules by default.
FATAL: could not find aircraft.json in any of the usual places!
The tar1090 installer prints this when readsb is not running, because tar1090 locates its data by looking for the JSON readsb writes. Fix readsb first, then rerun the tar1090 installer so it finds /run/readsb.
sudo bash -c "$(wget -nv -O - https://github.com/wiedehopf/tar1090/raw/master/install.sh)"
On the second run it restarted lighttpd and the map answered with HTTP 200.
HTTP 403 “Verification” when downloading adsb.lol/feed.sh
The ADSB.lol website sits behind a proof-of-work bot check that curl and wget cannot pass, so curl -fsL exits with code 22 and saves nothing. Use the GitHub raw URL from the ADSB.lol section above, which serves the same install.sh from the adsblol/feed repository.
Setup canceled (probably using Esc button)!
The ADSB.lol installer printed Unknown terminal: unknown and then this line when we ran it through a non-interactive SSH session, because its whiptail dialogs need a terminal. Run it from an interactive SSH login (or ssh -t) and the questions appear.
tee: /run/readsb/setGain: No such file or directory
readsb-gain tried to change the gain of a decoder that was not running. The new value is already saved in /etc/default/readsb, as our screenshot shows, and readsb uses it once it starts. There is nothing to fix beyond the dongle itself.
Where a home ADS-B feeder breaks down
The model above, one decoder fanned out to several consumers, holds up well. Builds go wrong in the assumptions about the radio side, and four of them come up again and again.
- More gain is better: wiedehopf’s gain guide warns that past a point you get no extra range, because the noise is amplified with the signal, and close aircraft start dropping out from overload. It suggests aiming for about 5 percent strong messages, and notes that the rtl-sdr AGC setting (
-10) actually runs ADS-B at maximum gain. - An LNA fixes a bad antenna position: it amplifies whatever reaches it, so an antenna blocked by a hill or a brick wall just gives you louder noise. Height and a clear view of the horizon come first.
- Feeding several networks costs range: it does not. Each feeder reads a copy of the decoded stream from port 30005, so ADSB.lol, FlightAware and others all get the same data for a few megabytes of RAM each.
- Any RTL-SDR stick drops in: the RTL-SDR Blog V4 needs a newer librtlsdr than bookworm shipped, so check which release you run before buying one. A 978 MHz UAT receiver is only useful in the United States and needs a second dongle.
If we were building one this week, we’d spend on the mast and the coax before anything electronic, put the SAWbird+ at the top of any run longer than a few metres, and let a spare Pi 4 do the rest. The same box can take a second always-on job, and our comparison of Pi-hole hardware from the Zero 2 W to a mini PC shows how much headroom each board really has.