Lat/Lon vs Lon/Lat: which order does each format use?

What a swap looks like on the map

Swapping the two numbers reflects the point across the lon = lat diagonal. That single geometric fact explains every "my points are in the ocean" report.

Take Chicago: latitude 41.88, longitude -87.63. Correct GeoJSON is [-87.63, 41.88]. Write it the navigation way — [41.88, -87.63] — and a lon-first renderer reads longitude 41.88, latitude -87.63: a spot in the Southern Ocean off Antarctica, south of the Indian Ocean, roughly antipodal to where you meant. A northern-hemisphere city becomes a southern-ocean nowhere; that mirror-image relocation is the fingerprint of a swap.

The insidious part is the confusion band. When both numbers are ≤ 90 in magnitude, both orderings are geographically legal — every latitude is a valid longitude — so nothing throws, nothing warns, and the point just lands somewhere plausible-but-wrong. Chicago's swap falls squarely in this band: -87.63 is a perfectly valid latitude, so no validator on earth can be certain the pair is reversed. You only get a hard signal when a value exceeds ±90 — which can only be a longitude, proving the pair is out of order.

How our inspector's swap detector works (honestly)

The universal inspector runs a deliberately conservative swap heuristic. It flags a pair as possibly-swapped only when it can prove it: a coordinate whose latitude slot exceeds ±90° (geographically impossible) while its longitude slot would be a valid latitude (≤ 90°). That is the classic [lat, lon]-written-as-[lon, lat] mistake, and when it's found the validator raises a coordinates-possibly-swapped warning with a one-click swapCoords fix:

Coordinates look lon/lat-swapped: some latitudes exceed ±90° but would be valid longitudes. GeoJSON order is [longitude, latitude].

What it can catch: any swap where the mistaken latitude lands above 90 or below −90 — which covers every point whose true longitude is beyond ±90° (most of Asia, Oceania, the Pacific, the far Atlantic). What it cannot catch: the confusion-band swaps like Chicago, where the reversed latitude is still a legal number. There is no way to know for sure, so the inspector warns rather than silently swapping — silently "fixing" an ambiguous pair would be worse than leaving it, because it might have been right all along. It surfaces the ambiguity and lets you decide.

See it flag a swap

Here's a Tokyo point written the wrong way round as GeoJSON — [35.68, 139.65] instead of [139.65, 35.68]. Because Tokyo's longitude (139.65) is well past 90°, the swapped latitude slot is impossible, so the inspector catches it with certainty:

Open in the Inspector — watch it flag the swap →

The link carries the geometry in the URL fragment only, so nothing is uploaded — the inspector decodes it in your browser, parses it, and shows the possibly-swapped warning with the swapCoords fix button. You can also paste either snippet in yourself:

// Swapped (wrong) — inspector flags it, Tokyo latitude 139.65 is impossible
{"type":"Point","coordinates":[35.68, 139.65]}

// Correct — longitude first
{"type":"Point","coordinates":[139.65, 35.68]}

How to fix swapped coordinates

Once you know a dataset is reversed, flipping it is mechanical. Pick the tool you're already in:

In the inspector (one click)

When the validator raises coordinates-possibly-swapped, press its swapCoords fix. It transposes every position's first two values in place and re-validates, so you see the corrected geometry (and its map render) immediately.

Python (Shapely)

from shapely.ops import transform

# Swap x/y (lon/lat) for any geometry, holes and all.
flipped = transform(lambda x, y: (y, x), geom)

JavaScript (Turf / GeoJSON)

import { coordEach } from '@turf/meta';

// Mutates in place; works for points, lines, polygons, collections.
coordEach(geojson, (coord) => {
  const tmp = coord[0];
  coord[0] = coord[1];
  coord[1] = tmp;
});

PostGIS

-- Swap X and Y for a column of geometries.
UPDATE my_table SET geom = ST_FlipCoordinates(geom);

Flip once, then verify a known landmark before you trust the whole batch — a double-swap puts you right back where you started.