Simplify GeoJSON

What this tool does

It thins out the vertices in your GeoJSON lines and polygons while keeping the overall shape. You feed it a Feature, a FeatureCollection, or a bare Geometry (like a Polygon or LineString), pick how aggressive to be, and get back simplified GeoJSON with far fewer points. I built it for "heavy" map data — the kind that makes a web map lag or trips a file-size limit on an API.

The intent it closes: "this geometry has way more points than the zoom level needs, and the file is too big." It runs entirely in your browser, so there's no upload and no hard size wall — coordinates never leave your machine. It does not shorten decimals (-122.123456789 stays as-is) and it does not preserve shared borders between features; for those, see the tips below.

How this tool works

One click on Simplify runs a parse-then-thin pass, all client-side.

1. Parse the input

Your text is parsed as JSON. If it isn't valid — a trailing comma, an unclosed bracket, a file path pasted instead of file contents — the status bar shows JSON parse error. and the output is left untouched. A clean parse is the only requirement before simplification runs.

2. Pick the engine

If the Turf.js library has loaded on the page, the tool calls turf.simplify(gj, {tolerance, highQuality: false, mutate: false}) — the same Douglas–Peucker implementation many GIS tools use. If Turf isn't available, it falls back to a built-in Douglas–Peucker pass that drops any vertex whose squared perpendicular distance from the line segment is at or below tolerance². Either way the result is the same kind of vertex reduction.

3. Thin each geometry

Simplification is applied to LineString, MultiLineString, Polygon, MultiPolygon, and recursively into GeometryCollection. Point and MultiPoint geometries pass through unchanged — there's nothing to thin in a single coordinate. A FeatureCollection is walked feature by feature, each simplified with the same tolerance, with its properties carried over verbatim.

4. Keep polygons valid

A linear ring needs at least four positions (the last repeating the first) to be a valid polygon. If simplifying a ring would drop it below four points, the tool reverts that ring to its original coordinates rather than emit a broken polygon. So tiny polygons may simplify less than you'd expect — that's deliberate, not a bug.

5. Report and export

The output pane shows the simplified GeoJSON, always pretty-printed with a 2-space indent. The status bar reports the run, for example Simplified at tol=0.01. Size 48210 -> 9120 (81% smaller). — the percentage is the drop in the serialized text length, not a vertex count. Copy puts the result on your clipboard and Download .geojson saves it as simplified.geojson.

Options

Tolerance (degrees)

The single control, [data-role="tolerance"], sets how aggressive the vertex removal is. The algorithm measures how far each point sits from the straight line between its neighbours; if that distance is within the tolerance, the point is dropped. The default is 0.01, and any value that is zero, negative, or not a finite number falls back to 0.01.

The units are coordinate degrees, because standard GeoJSON coordinates are longitude/latitude degrees and the distance is measured in those same units. As a rough guide near the equator: 0.0001 is about 11 m (very detailed), 0.001 about 110 m (good for city maps), and 0.01 roughly 1.1 km (fine for country-level outlines). If your shapes turn into a jagged mess of triangles, the tolerance is too high — add another zero after the decimal point. If your coordinates look like [450231, 5671234] you're in a projected system (UTM, Web Mercator), the tool still runs, but this distance guide won't apply.

Example

Input — a LineString with a nearly-flat middle point:

{
  "type": "LineString",
  "coordinates": [[0, 0], [0.00001, 0.00001], [1, 1]]
}

Output, simplified at tolerance 0.01:

{
  "type": "LineString",
  "coordinates": [[0, 0], [1, 1]]
}

The middle point sits well within the 0.01 threshold of the line from start to end, so it's dropped without meaningfully changing the shape at this scale. The output comes back pretty-printed at 2-space indent.

Tips & common pitfalls

• Topology is not preserved. Each feature is simplified on its own. Two adjacent polygons that share a border can "pull apart" at higher tolerances, leaving gaps or overlaps. For border-preserving work you need a TopoJSON workflow.
• Tiny polygons resist simplification. Because a ring that would fall below four points reverts to its original, a small polygon may not shrink at all even at a high tolerance — and a too-aggressive tolerance can still distort it enough to render oddly in the GeoJSON Viewer.
• Start small, go bigger. Begin around 0.0001 to strip redundant points, then step up to 0.0005 or 0.001 if the file is still too large. It's easier to thin more than to recover a shape that's already gone crunchy.
• This trims points, not decimals. It reduces the number of vertices, never the length of each coordinate. To shorten -122.123456789, that's a precision job — see the GeoJSON Formatter.

Troubleshooting

The output looks identical to the input.

The tolerance is probably too low for your data. On a high-resolution file, 0.0001 may find no points worth removing. Bump it to 0.001 or 0.01 and click Simplify again. Note that a tolerance of zero or below is ignored and treated as 0.01.

My polygons turned into weird triangles or straight lines.

The tolerance is too high — you've told the algorithm that points within a large distance don't matter, so it keeps only the most extreme corners. Add a zero after the decimal (for example change 0.1 to 0.01) and retry.

I get a "JSON parse error."

The input must be valid JSON. Make sure you pasted the file contents and not a file path, and check for trailing commas or unclosed brackets if you've been hand-editing the text.

My points stayed exactly the same.

That's expected. Point and MultiPoint geometries are passed through unchanged — there are no intermediate vertices to remove. Simplification only affects lines and polygons.

FAQ

What algorithm does this use?

Douglas–Peucker, the standard for thinning lines and polygons while keeping the overall shape. When the Turf.js library is present the tool uses turf.simplify; otherwise it runs an equivalent built-in Douglas–Peucker fallback.

Does this handle shared borders between polygons?

No. Every feature is treated independently. To simplify a map of counties or states while keeping borders perfectly aligned, use a TopoJSON-based tool such as Mapshaper.

Why is the tolerance in degrees instead of meters?

Standard GeoJSON coordinates are degrees of longitude and latitude, and the algorithm measures distance in those same units, so the threshold has to be in degrees too. The Options section has a rough degrees-to-meters guide for the equator.

Are my map files uploaded to a server?

Never. Everything runs in your browser via JavaScript, so your GeoJSON stays on your machine. That also makes it fast on large files and avoids any upload size wall.

Can I simplify multiple features at once?

Yes. Paste a FeatureCollection and the tool walks every feature, simplifying each with your chosen tolerance and keeping its properties. The status bar reports the total size reduction across the whole collection.