Where is the wildfire burning right now?

A fire shows up from space as a patch of ground that’s suddenly far hotter than everything around it. Satellites carry heat-sensing cameras. When one flies overhead and sees a pixel glowing in the infrared (heat light our eyes can’t see), it flags that spot as a likely fire. NASA collects those flags and publishes them within a few hours through a service called FIRMS, so you can see active fires almost as they happen.

Which data to use, and how

Use this dataset: FIRMS VIIRS 375 m active fire (short name VNP14IMGTDL_NRT). It’s the easiest to start with. It’s near-real-time (published within ~3 hours of the satellite passing over), it arrives as a tidy list of fire detections rather than a giant image you have to crunch, and at 375 m per pixel it’s the sharpest option here. The older FIRMS MODIS 1 km product covers the same idea at a coarser 1 km. That’s handy for a longer history, but start with VIIRS.

Then do these steps (the runnable code further down does all of this; this is just the idea):

1. Pick your area. A small latitude/longitude box around the region you care about, plus your time window (say the last 24 hours, or the last few days).
2. Pull the detections. FIRMS returns one row per “hot pixel”: its location, the time the satellite saw it, and a couple of numbers describing it.
3. Keep the confident ones. Each detection comes with a confidence rating. Drop the low-confidence ones so a stray warm spot doesn’t get mistaken for a real fire.
4. Plot them. Put the points on a map. Colour or size them by Fire Radiative Power (FRP), a measure of how much heat energy the fire is throwing off, i.e. how intense it is.
5. Watch it move (optional). Stack several satellite passes in order and the dots march across the map, showing which way the fire is spreading.

That’s the whole method. Below, “How a scientist answers this” names the exact tools, and the Run it cell does it live on synthetic data so you can see each step work.

What you can find out

• Where fires are burning, almost live. VIIRS and MODIS flag thermal anomalies (pixels whose infrared heat signal spikes far above the surrounding ground). FIRMS publishes them within ~3 hours, several times a day.
• How intense a fire is. Fire Radiative Power (FRP) estimates how much energy each detection is releasing, so you can tell a smouldering edge from a raging front.
• Which way it’s spreading. Line up successive satellite overpasses and the detections trace the fire’s advance over hours and days.

What it can’t tell you

• Small or cool fires. A fire smaller than one pixel, or hidden under cloud or thick smoke, can slip through undetected. The satellite only flags a pixel when its average heat is high enough, and a tiny flame inside a 375 m square may not move the needle.
• The exact fire boundary. Detections are dots on a coarse grid, not a clean outline. For the actual burned footprint you map it after the fire with burn severity (dNBR), which compares before-and-after greenness.
• Whether every hot spot is really a fire. Gas flares, volcanoes and hot industrial sites also glow in the infrared and can trip the same detector. The point tells you “something here is hot,” not “this is definitely a wildfire.” You have to check the context.

Gotchas to watch for

• Confidence is not optional. Every detection carries a confidence level (low / nominal / high). Low-confidence hits include a lot of borderline warm pixels. The simplest fix is to filter to nominal-and-above before you trust a point, especially during a real response.
• Clouds and smoke hide fires. The heat sensor can’t see through thick cloud or a heavy smoke plume, so a quiet-looking map may just mean the view is blocked, not that the fire stopped. Cross-check the most recent few overpasses rather than a single one.
• Hot but not a wildfire. Permanent heat sources like flares, smelters, and volcanoes show up day after day in the same spot. If a “fire” never moves and never goes out, it’s probably industrial. Compare against context or a known-flare list before raising the alarm.
• Near-real-time means slightly rough. The _NRT (near-real-time) stream trades a little accuracy for speed so responders get it fast; a more carefully reprocessed “standard” version arrives later. For live response the NRT product is the right call. Just know it can be revised.

The real-data code

The Run it cell above runs the method on synthetic data (no login). Below is the whole recipe against the real archive: pull the detections, keep the confident ones, count them, and plot them on a map coloured by intensity. FIRMS is a REST service, so you query it over HTTP with a free FIRMS map key (get one with your Earthdata Login at firms.modaps.eosdis.nasa.gov/api/).

import io, requests, numpy as np, pandas as pd
import matplotlib.pyplot as plt

MAP_KEY = "YOUR_FIRMS_MAP_KEY"        # free at https://firms.modaps.eosdis.nasa.gov/api/
aoi = (-122.0, 39.6, -121.2, 40.1)    # (West, South, East, North) — Northern California
day_range, start = 1, "2025-01-08"    # last N days ending after this date

# 1. Pull the detections. FIRMS returns one CSV row per VIIRS 375 m hot pixel
#    inside the box — its location, the overpass time, a confidence rating, and FRP.
src = "VIIRS_SNPP_NRT"                 # the VNP14IMGTDL_NRT 375 m near-real-time stream
W, S, E, N = aoi
url = (f"https://firms.modaps.eosdis.nasa.gov/api/area/csv/{MAP_KEY}/{src}/"
       f"{W},{S},{E},{N}/{day_range}/{start}")
df = pd.read_csv(io.StringIO(requests.get(url, timeout=60).text))
print(f"{len(df)} raw hot-pixel detections returned")

# 2. Keep the confident ones. VIIRS confidence is l/n/h (low/nominal/high);
#    drop the low-confidence borderline warm pixels so a stray spot isn't a "fire".
conf = df["confidence"].astype(str).str.lower()
fires = df[conf.isin(["n", "h"])].copy()
fires["frp"] = pd.to_numeric(fires["frp"], errors="coerce")
fires = fires.dropna(subset=["frp", "latitude", "longitude"])

# 3. Count the answer: how many real detections, how hot, and where the hottest is.
n = len(fires)
hottest = fires.loc[fires["frp"].idxmax()]
print(f"VERDICT: {n} confident active-fire detections in the box; "
      f"total FRP {fires['frp'].sum():.0f} MW, hottest at "
      f"({hottest['latitude']:.3f}, {hottest['longitude']:.3f}) = {hottest['frp']:.0f} MW")

# 4. Plot the points on a map, sized and coloured by FRP (fire intensity).
plt.figure(figsize=(7, 6))
sc = plt.scatter(fires["longitude"], fires["latitude"], c=fires["frp"],
                 s=10 + fires["frp"] / fires["frp"].max() * 200,
                 cmap="inferno", norm="log", edgecolor="k", linewidth=0.2)
plt.colorbar(sc, label="Fire Radiative Power (MW)")
plt.xlim(W, E); plt.ylim(S, N)
plt.xlabel("longitude"); plt.ylabel("latitude")
plt.title(f"VIIRS 375 m active fire — {n} detections from {start} (+{day_range}d)")
plt.tight_layout(); plt.show()

# Before you trust it: a hot spot that never moves across successive overpasses is
# probably an industrial flare or volcano, not a wildfire (see the gotchas above) —
# cross-check against a known-flare list or a second overpass before raising the alarm.

Where the data comes from

The fire detections come from instruments flying on NASA and NOAA satellites: VIIRS (a heat-and-light camera on the Suomi-NPP and NOAA-20 satellites) and the older MODIS (on the Terra and Aqua satellites). NASA’s FIRMS (Fire Information for Resource Management System) gathers their hot-pixel flags and serves them to the public within a few hours through one free login (Earthdata Login). This near-real-time stream feeds the Respond phase of the NASA Disasters program.

Sources

• FIRMS (Fire Information for Resource Management System): https://firms.modaps.eosdis.nasa.gov/
• VIIRS 375 m active fire product (VNP14IMGTDL_NRT): https://www.earthdata.nasa.gov/data/instruments/viirs/viirs-i-band-375-m-active-fire-data
• NASA Disasters program (Respond phase): https://disasters.openveda.cloud/