Nearly all magnitude 8 and larger earthquakes since 1965 struck at subduction zones (USGS catalog).

The Query

The USGS FDSN event web service is free, needs no key and answers in GeoJSON. Three parameters are enough here, a start date, a minimum magnitude and a sort order.

const params = new URLSearchParams({
  format: "geojson",
  starttime: "1965-01-01",
  minmagnitude: "8",
  orderby: "magnitude",
});

const res = await fetch(`https://earthquake.usgs.gov/fdsnws/event/1/query?${params}`);
if (!res.ok) throw new Error(`USGS API answered ${res.status}`);
const { features } = await res.json();

const quakes = features.map(({ properties, geometry }) => {
  const [lon, lat, depthKm] = geometry.coordinates;
  return {
    mag: properties.mag,
    place: properties.place,
    year: new Date(properties.time).getUTCFullYear(),
    lat, lon, depthKm,
  };
});

const shallow = quakes.filter(q => q.depthKm <= 70);
console.log(`${quakes.length} quakes of M8+ since 1965, ${shallow.length} of them 70 km deep or less`);

for (const q of quakes.slice(0, 5)) {
  console.log(`M${q.mag} ${q.year} ${q.place} (${q.depthKm} km)`);
}
for (const q of quakes.filter(q => q.depthKm > 70)) {
  console.log(`Deep exception: M${q.mag} ${q.year} ${q.place}, ${q.depthKm} km`);
}

Save it as megathrust.mjs and run node megathrust.mjs (Node 18 or later), or paste it into a browser console.

What It Prints

On November 6, 2026 the catalog returned 49 earthquakes of magnitude 8 or more since 1965, and 44 of them started 70 km deep or less. The top five are all shallow subduction ruptures, Sumatra 2004 and Tohoku 2011 at M9.1, then Kamchatka 2025 and Maule 2010 at M8.8, then the Rat Islands in 1965 at M8.7.

The five exceptions are deep, from 122 km under Peru to 645 km. They break inside the sinking slab, not on the plate contact, which is the other family of subduction zone quakes the USGS describes.

Why Shallow Matters

Megathrust ruptures sit close to the seafloor, so they can lift the ocean above them, which is why the largest ones set off tsunamis. The strongest on record, the M9.5 Valdivia earthquake of 1960, predates this query. Its depth was 33 km, as the Live Atlas record of the Valdivia earthquake shows. To see the shallow versus deep split for recent quakes, this depth explorer plots both, and the deadliest earthquakes table lists the human toll of the big ones.

Two Points, One Dot on the Map

The hypocenter is where the rupture begins underground, and the epicenter is the point straight above it, the one shown on maps. Not to scale.

The USGS primer on the science of earthquakes calls the surface along which rock slips the fault plane. The slip starts at one point on it, the hypocenter, also called the focus. The epicenter sits directly above, so the distance between the two is simply the depth of the quake.

Locating that point explains why maps show the epicenter. P waves travel faster than S waves, so the delay between them on one seismogram gives the distance to the source but not the direction. That distance draws a circle around the station, and with three stations the circles cross at one place on the surface, the epicenter.

What the USGS Feed Returns

The USGS GeoJSON summary feeds are free, need no key and are updated every minute. URLs follow one pattern, summary/{magnitude}_{period}.geojson, with magnitudes significant, 4.5, 2.5, 1.0 or all, and periods hour, day, week or month.

Each earthquake is a GeoJSON feature whose geometry is a point.

"geometry": { "type": "Point", "coordinates": [longitude, latitude, depth] }

The first two numbers are the epicenter. The third is the depth of the hypocenter in kilometers. Note the order, longitude first, which trips up anyone used to writing latitude first.

The Code

Node 18 or later has fetch built in, and the same code runs in a browser.

const FEED = "https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/4.5_week.geojson";

const res = await fetch(FEED);
if (!res.ok) throw new Error(`USGS feed answered ${res.status}`);
const { features } = await res.json();

const quakes = features.map(({ properties, geometry }) => {
  const [lon, lat, depthKm] = geometry.coordinates;
  return {
    place: properties.place,
    mag: properties.mag,
    time: new Date(properties.time).toISOString(),
    epicenter: { lat, lon },          // the point on the map
    hypocenterDepthKm: depthKm,       // the same point, this far down
    shallow: depthKm < 70,
  };
});

const deepest = [...quakes].sort((a, b) => b.hypocenterDepthKm - a.hypocenterDepthKm)[0];
const shallowShare = quakes.filter(q => q.shallow).length / quakes.length;

console.log(`${quakes.length} quakes of M4.5+ this week, ${Math.round(shallowShare * 100)}% shallow`);
if (deepest) console.log(`Deepest: M${deepest.mag} ${deepest.place}, ${deepest.hypocenterDepthKm} km down`);

Save it as quakes.mjs and run node quakes.mjs. Swap 4.5_week for all_day to include the smaller quakes as well.

Why Depth Matters

A quake counts as shallow when its focus is less than 70 km down, and shallow events are the most dangerous because the rupture is close to the people above it. Others start as deep as 700 km, inside slabs of plate sinking at subduction zones, which is why a single dot on a flat map can hide very different events. This depth explorer plots shallow against deep quakes, and the magnitude calculator compares the energy of any two.

What the Data Describes

The aurora forms about 80 to 500 km up, where incoming electrons excite oxygen (green and red) and nitrogen (blue and purple). Not to scale.

According to NOAA's page on the aurora, electrons accelerated in the magnetotail, on the night side of the planet, follow Earth's magnetic field down toward the poles and collide with oxygen and nitrogen in the upper atmosphere. Each collision lifts an atom or molecule into a higher energy state, and the light comes out when it drops back, much like a neon tube. The glow forms two rings, the auroral ovals, roughly centered on the magnetic poles. In a band from about 60 to 75 degrees of latitude, displays happen on most nights of the year, and a strong geomagnetic storm pushes the ovals far enough to reach parts of the United States, Europe and Asia.

Two numbers capture that behavior, and both are published as JSON.

Endpoint 1, the Planetary Kp Index

https://services.swpc.noaa.gov/products/noaa-planetary-k-index.json returns an array of objects, one per three-hour block over the past several days.

{"time_tag":"2026-10-26T00:00:00","Kp":0.33,"a_running":2,"station_count":8}

Kp runs from 0 to 9 and NOAA counts a geomagnetic storm from Kp 5 upward. The Kp explainer walks through what each step means for the sky. The time_tag is in UTC even though it carries no Z, so parse it with that in mind.

Endpoint 2, the OVATION Aurora Forecast

https://services.swpc.noaa.gov/json/ovation_aurora_latest.json holds the output of the OVATION model behind NOAA's 30-minute aurora forecast. The file has four keys, Observation Time, Forecast Time, Data Format and coordinates. Each coordinate is a [Longitude, Latitude, Aurora] triple, one per whole degree.

[0, -90, 7], [0, -89, 0], [0, -88, 9]

The aurora value is an intensity, and NOAA derives a rough viewing probability from it by assuming a linear relationship, so a higher number means a likelier display. The lead time is 30 to 90 minutes, the time the solar wind takes to travel from the L1 observation point to Earth.

One trap is the longitude, which runs from 0 to 359 rather than from -180 to 180. A point at 74 degrees west has to be looked up as 286.

The Checker

Node 18 or later has fetch built in, and the same code runs in a browser.

const KP_URL = "https://services.swpc.noaa.gov/products/noaa-planetary-k-index.json";
const OVATION_URL = "https://services.swpc.noaa.gov/json/ovation_aurora_latest.json";

async function getJson(url) {
  const res = await fetch(url);
  if (!res.ok) throw new Error(`${url} answered ${res.status}`);
  return res.json();
}

async function latestKp() {
  const rows = await getJson(KP_URL);
  const last = rows[rows.length - 1];
  return { time: last.time_tag, kp: last.Kp, storm: last.Kp >= 5 };
}

async function auroraAt(lat, lon) {
  const data = await getJson(OVATION_URL);
  const x = ((Math.round(lon) % 360) + 360) % 360; // -74 becomes 286
  const y = Math.round(lat);
  const cell = data.coordinates.find(([cx, cy]) => cx === x && cy === y);
  return { forecastTime: data["Forecast Time"], aurora: cell ? cell[2] : null };
}

const [kp, spot] = await Promise.all([latestKp(), auroraAt(69.65, 18.96)]);
console.log(`Kp ${kp.kp} at ${kp.time} UTC${kp.storm ? ", geomagnetic storm" : ""}`);
console.log(`Aurora value near Tromsø ${spot.aurora} (forecast for ${spot.forecastTime})`);

Save it as checker.mjs and run node checker.mjs. Swap the coordinates for your own location.

Before You Ship It

The OVATION file holds one value for every whole degree of the globe, so it is worth downloading once and reusing for many lookups rather than fetching it per point. Both files say when they were produced, so compare Forecast Time and the last time_tag with the current time before trusting a cached copy. Finally, a high Kp alone does not promise a show at your location, which is why the checker reads the gridded forecast as well.

Each whole step in magnitude means 10 times the amplitude and about 32 times the energy (USGS). Three steps add up to about 32,768 times the energy.

The arithmetic is logarithmic. On its page about magnitude, energy release and shaking, the USGS counts each whole-number step as a tenfold rise in the amplitude traced on a seismogram, or roughly 32 times more energy. Each earthquake ends up with a single magnitude, yet several methods can produce it. Richter's original scale, ML, held only for California earthquakes within 600 km of one type of seismograph, and the USGS now keeps it mainly for small local quakes. Its list also names a short-period surface wave magnitude (Mblg) and an energy magnitude (Me).

For larger events the agency prefers moment magnitude, written Mw, as the more accurate measure. It starts from the seismic moment, which multiplies the rigidity of the rock by the area of fault that slipped and by the amount of slip. On that basis, a rupture of the whole San Andreas Fault, about 1,400 km long with some 10 m of slip, would come out near Mw 8.47.

Shaking is measured separately. Intensity changes from town to town, mostly with distance from the rupture, and the United States grades it in Roman numerals on the Modified Mercalli scale.

The gap between two numbers grows fast. A magnitude 9.2 releases about 89 times more energy than a 7.9, and this earthquake magnitude calculator runs the same comparison for any two quakes.