November 2, 2026

Make Your Own: Flights Overhead

Every airplane overhead is already broadcasting where it is. This is the recipe for the radar scope that runs on my TV — one free web page, one tiny server, and the planes' own transponder data. It costs nothing, and it takes about half an hour.

What you're making

A web page that draws a radar scope centred on your house: range rings at 10, 20, and 30 nautical miles, your towns and airports labelled where they actually are, and every aircraft inside the circle drawn as a moving blip — flight number, aircraft type, altitude, coloured by height. A side rail lists the nearest traffic. It refreshes every 15 seconds, and between refreshes the planes glide, because the page moves them along their last reported heading and speed.

It's one of the screens in my house — the full system is written up in The House Screens Project — but this page stands alone. You don't need the rest of the system to run it.

The one idea to steal

The planes are already broadcasting. Almost every aircraft carries a transponder that announces its position, altitude, speed, and identity several times a second — a system called ADS-B, flown for safety, free for anyone to receive. Volunteers all over the world run small receivers, pick up those broadcasts, and pool them. The community network adsb.lol aggregates the pool and answers one simple question over the web: what is within this many miles of this point, right now?

So the page doesn't track anything, scrape anything, or need an account or a key. It asks that question every 15 seconds and draws the answer itself. That second part matters: my first version embedded a ready-made map from another community flight project, adsb.fi, inside the page, and on the TV it never finished loading — a white pane and a spinner, forever. Drawing the scope from the raw data is what made it work on every screen in the house. Own the drawing; borrow the data.

Credit where it's due: both of those networks exist because volunteers run the receivers — people with small antennas on roofs and windowsills, feeding what they hear into a common pool and giving it away. This page is a drawing. The sky underneath it is theirs.

What you need

• The page. It's free, in my open-source house-screens repo: github.com/Caitria/MaudeAtHome, at screens/pages/flights-overhead.html. Download that one file.
• Any computer that stays on — a Raspberry Pi, an old laptop, or the machine you're reading this on. It runs a server the size of a paragraph (below).
• A screen for it. A TV you can cast a browser tab to (Chromecast, Google TV), a TV or monitor with any browser, or a spare tablet on a shelf.
• Your home's latitude and longitude. Long-press your house in any map app; it will show you two numbers. Those two numbers are the main edit — the code below shows placeholders where yours go.
• About 30 minutes, most of it spent watching planes.

The steps

• Step 1 — Tell the page where you live. Open flights-overhead.html in any text editor. Near the top of the script, set YOUR_LAT and YOUR_LON to your coordinates. Then edit the PLACES list: your town, the next towns over, the airports near you, each with its coordinates. Those become the labels on the scope, so the blips have somewhere to be relative to.
• Step 2 — Meet the one real problem. The page runs in a browser, and browsers refuse to fetch data from a site that hasn't sent a permission header. adsb.lol doesn't send one (a rule called CORS), so the page can't ask it directly. The fix is a tiny proxy: a small program on your own machine that fetches the data server-side — servers don't have the browser's rule — and hands it to your page as though it came from the same place. This is the whole trick, and it's fifteen lines:

# flights_server.py — serves the Flights Overhead page and its data.
# Run:  python3 flights_server.py    then open http://THIS-MACHINE:8081/
import urllib.request
from http.server import BaseHTTPRequestHandler, HTTPServer

LAT, LON = YOUR_LAT, YOUR_LON   # <-- your house: latitude, longitude
RADIUS = 30                 # nautical miles around the house
PORT = 8081

PAGE = open("flights-overhead.html", "rb").read()

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == "/adsb":
            url = "https://api.adsb.lol/v2/point/%s/%s/%s" % (LAT, LON, RADIUS)
            req = urllib.request.Request(url,
                    headers={"User-Agent": "flights-overhead/1.0"})
            body = urllib.request.urlopen(req, timeout=10).read()
            ctype = "application/json"
        else:
            body, ctype = PAGE, "text/html; charset=utf-8"
        self.send_response(200)
        self.send_header("Content-Type", ctype)
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)
    def log_message(self, *args):
        pass

HTTPServer(("0.0.0.0", PORT), Handler).serve_forever()

• Step 3 — Point the page at your proxy. In the page, find the line that fetches the data — it reads http://CASTPI_LAN_IP:8081/adsb (Castpi is my Pi's name; the file ships with the placeholder). Replace CASTPI_LAN_IP with your server machine's address on your home network — it looks like 192.168.1.50, and your router's app will tell you. Put flights_server.py in the same folder as the page, set your coordinates at its top too, and run it: python3 flights_server.py. Leave it running.
• Step 4 — Put it on the big screen. On any computer, open http://your-server-address:8081/ in Chrome — you should see your sky. Then cast it: Chrome's menu → Cast → your TV, and the scope is on the wall. If your TV or a tablet has its own browser, you can open the same address there and skip casting. In my house the page is one tap on a phone controller, alongside the other screens.
• Step 5 — Leave it. That's the build. It will sit there all day being quietly correct: arrivals stacking up over the airport, a Cessna doing circuits at 500 feet, the red-eye freight going over at 3 AM whether anyone watches or not.

Honest limits

• It's transponders, not radar. An aircraft that isn't broadcasting ADS-B isn't on the scope. Most airliners and most modern small planes broadcast; some older and some military traffic doesn't.
• Coverage is volunteers. If nobody near you runs a receiver, low aircraft far from the next town over may be missing. Coverage near cities is dense; it thins with altitude and distance.
• It's a portrait, not an instrument. The data is a few seconds old, the page refreshes every 15 seconds, and between refreshes the planes are drawn where they should be, not measured where they are. Never navigate by it. Glance by it.
• Be polite to the commons. adsb.lol is a community project giving this away. Fifteen-second updates are plenty; don't hammer it, and if you end up loving this, the way to pay it back is the next section.

Level up: become one of the receivers

The deluxe version of this project is a USB radio dongle (a software-defined radio, about $35) on a small antenna, plugged into the same always-on computer. It hears the broadcasts directly from your roof — no internet, no aggregator — and the same page can drink from your own receiver instead. It also makes you one of the volunteers the network runs on: feed your receptions back, and the next person's scope gets better. My page has a placeholder for exactly this. We haven't bought the dongle yet; it's a separate decision, and the scope is complete without it.

That's the whole recipe. The sky over your house is already talking — this is just a polite way to listen in, drawn nicely.

FILED UNDER — HOUSE SCREENS · MAKE YOUR OWN · BLOG · NOVEMBER 2026