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) — coordinate precision is the tool for that. It does keep shared borders in step, which is what the keep shared borders box controls.

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. Thin, once per shared run

The thinning itself is Douglas–Peucker: a vertex is dropped when its perpendicular distance from the straight line between the points that survive around it is at or below the tolerance. It runs in the page — there is no library to download, so the first run starts immediately and the tool works offline.

With keep shared borders on, the collection is first pulled apart into the runs of coordinates it is really built from. A border between two polygons is one run: along it, every interior point has the same two neighbours in both features, so the run is recognised as shared and thinned once. Both polygons are then rebuilt from the thinned run and cannot drift apart. With the box off, every ring is thinned on its own — faster, and fine for a file with no touching features.

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 thinning would drop it below four, the tool puts the original coordinates back rather than emit a broken polygon. In shared-border mode that check happens on the shared run itself, so the restored detail is still shared and the neighbours stay aligned. Only when a whole feature is smaller than the tolerance does it fall back ring by ring — which does cost the alignment on that one feature, and is a sign the tolerance is too coarse for it.

5. Report and export

The output pane shows the simplified GeoJSON, always pretty-printed with a 2-space indent. Feature ids and properties are carried over verbatim. The status bar reports vertices before and after, bytes minified-against-minified so the percentage means something, and — in shared-border mode — how many runs the file was built from and how many of them were reused by more than one feature. 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, implemented in the page itself — no library is fetched. In shared-border mode it is applied to the extracted runs rather than to each ring, which is the same idea TopoJSON-based tools use.

Does this handle shared borders between polygons?

Yes, with keep shared borders on — which is the default. A run of coordinates that two features share is thinned once and both are rebuilt from it, so a map of counties simplifies without opening slivers along the borders. It only works when the shared coordinates are identical; two layers digitised separately will not match, and the status line will show no reused runs. If you want that structure in the file itself rather than just for one pass, convert to TopoJSON.

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.