simplemaplab

GeoJSON Viewer — View & Inspect GeoJSON Online

Drag any .geojson or .json file onto the map. Features render instantly with auto-fit bounds, click-to-inspect properties, layer toggles, and one-click conversion to KML. Worldwide — all parsing happens in your browser. No signup, no upload, no API key.

The GeoJSON Viewer parses your file with native JSON.parse, validates the structure against RFC 7946, and renders the result with MapLibre GL JS. It accepts a full FeatureCollection, a single Feature, or a bare Geometry. Loaded data can be exported back to GeoJSON (re-formatted) or converted to OGC KML 2.2 with names and properties preserved.

Drop a .geojson file anywhere in this box, or use the controls above. Max file size 8 MB. Files are parsed locally — nothing is uploaded.
Or try a sample:
GeoJSON preview
No file loaded
📍
Load a GeoJSON file to see every feature listed here.
  • Drag a file into the dashed box
  • Or paste raw text and click Render this text
  • Or click a sample chip above

How to use the GeoJSON Viewer

  1. Drag your .geojson file onto the map. Drop the file anywhere in the dashed input zone, paste raw JSON into the text box, fetch from a public URL, or click "Upload file" to pick it from a folder. The viewer accepts FeatureCollection, single Feature, or bare Geometry — and any extension (.geojson, .json, .topojson is not supported but plain GeoJSON-as-.json works).
  2. See every Feature on the map. Point geometries become green dots (with labels if a "name" property exists), LineString and MultiLineString become teal paths, and Polygon and MultiPolygon become a blue fill with a darker outline. The map auto-fits to the bounding box of every feature.
  3. Click a feature for properties. Click any feature in the sidebar or directly on the map to highlight it red and pop the properties table at the bottom of the tool. Every property is shown — strings, numbers, and JSON-encoded sub-objects all included. Use the filter toggles to hide a geometry group while inspecting another.
  4. Export, convert, or grab the bbox. The bottom-right export row downloads a fresh GeoJSON, converts the file to KML, converts to GPX (for Garmin, Strava, or any GPS device), or copies the compact JSON to your clipboard. The bbox is shown in the stats block — click "Copy" to put the four-number string (west, south, east, north) on your clipboard for use in any GIS tool.

What people use the GeoJSON Viewer for

Inspect a GeoJSON before you wire it into a web map

You have a GeoJSON file ready to drop into a Leaflet or MapLibre app and you want to confirm the geometry, property names, and bbox before writing the source code. Drop the file here, scroll the feature list, click a few features to inspect properties, and you have a complete mental model in 30 seconds.

Convert GeoJSON to KML for Google Earth or Garmin

Most modern data sources publish GeoJSON, but Google Earth Pro, Garmin BaseCamp, and older GPS units still want KML. Drop the .geojson here, click "⬇ KML," and you have a clean OGC KML 2.2 file with names and properties preserved as Placemark <name> and <ExtendedData>.

Audit a city or county boundary file

OpenStreetMap, the US Census TIGER files, and Natural Earth all publish boundaries as GeoJSON. This viewer renders them on an OSM basemap so you can quickly check that the polygon has the right number of rings (no overshoots), the bbox makes sense, and the metadata properties contain the fields your app expects.

Visualise an Overpass API or Wikidata export

Overpass Turbo exports query results as GeoJSON. Wikidata SPARQL results can be coerced to GeoJSON via tooling. Both produce files with rich property bags — drop into this viewer to see every result on a map and click through to read every property of every feature.

Trace a hiking, biking, or vehicle GPS route

Strava, Garmin Connect, Wahoo, and most modern GPS apps either export GeoJSON directly or have GPX-to-GeoJSON converters. Drop the route into this viewer to verify the LineString is intact, the bbox covers the right region, and any waypoint Points are correctly labelled.

Pre-flight checks for an ArcGIS or QGIS export

When ArcGIS Pro or QGIS export GeoJSON, occasionally the CRS is wrong (not EPSG:4326), the property names get truncated, or a Polygon ends up missing its closing point. This viewer is a quick sanity check — if it renders here, it will render in any modern web mapping library.

GeoJSON format reference

The minimal valid GeoJSON file is a FeatureCollection containing one or more Feature objects. Each Feature wraps a Geometry (one of the seven RFC 7946 types) plus a free-form properties bag. Coordinates are always [longitude, latitude] in WGS84 (EPSG:4326).

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "properties": { "name": "Golden Gate Bridge", "year": 1937 },
      "geometry": {
        "type": "Point",
        "coordinates": [-122.4783, 37.8199]
      }
    },
    {
      "type": "Feature",
      "properties": { "name": "Bay Bridge route" },
      "geometry": {
        "type": "LineString",
        "coordinates": [
          [-122.388, 37.808],
          [-122.302, 37.798]
        ]
      }
    }
  ]
}

The type field is required at every level. Polygons are arrays of linear rings (the first is the outer boundary, the rest are holes); each ring must be a closed array (first and last point equal). MultiPoint, MultiLineString, MultiPolygon, and GeometryCollection let you bundle multiple shapes into a single feature.

Supported types

Common pitfalls

GeoJSON vs KML — which should you use?

GeoJSON is the modern web-mapping standard: every JS mapping library consumes it natively, it is JSON (so any backend can produce it), and the spec (RFC 7946) is concise. KML is the Google Earth / GPS-device standard: XML, richer animation and camera support, but heavier and less common on the web. Convert between the two in one click using this viewer — load GeoJSON and export KML, or visit the KML Viewer and go the other direction.

Related geographic-data tools

For KML files: KML Viewer. For GPX tracks from Strava, Garmin, AllTrails, or Komoot: GPX Viewer. For plotting a CSV of coordinates: CSV to Map. For dropping pins by hand: Pin Drop Map. For US ZIP codes as data points: Map with ZIP Codes. For US county choropleths: Map with Counties. For drawing geometries by mouse: Map Drawer.

Frequently asked questions

GeoJSON is a JSON-based format for encoding geographic data. It was first published by an open community in 2008 and formally standardised as RFC 7946 in 2016 by the IETF. It supports Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon, and GeometryCollection geometries, each optionally wrapped in a Feature with arbitrary properties, and collected into a FeatureCollection. Every major web-mapping library (Leaflet, MapLibre GL, Mapbox GL, ArcGIS API for JavaScript, OpenLayers) consumes GeoJSON natively.
Drop the file onto this page. The viewer reads the JSON with the browser's FileReader, validates the structure, and renders every feature on a MapLibre/OpenStreetMap base map. No software install, no signup, no upload to any server. The same works for .json files containing GeoJSON, for files pasted into the text box, and for files fetched from a public URL.
The browser ingest is capped at 8 MB to keep the page responsive. For a typical GeoJSON dataset — a few hundred features, even with rich polygon geometry — that is plenty. For very large datasets (country-level boundary files, national parcel data, etc.) we recommend simplifying first with mapshaper.org (which can also run locally in the browser) before loading into the viewer.
All seven RFC 7946 geometry types: Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon, and GeometryCollection (expanded into its component features for rendering). The viewer also accepts a bare Feature or a bare Geometry — both are auto-wrapped into a FeatureCollection so the rest of the tool works identically.
Yes — every property of every feature is preserved and shown in the property table when the feature is clicked. The label on the map (for Point features) comes from the "name", "NAME", or "title" property if present. The sidebar feature list also picks up the name. Property values are shown as strings, numbers, or compact JSON for sub-objects.
Yes. After loading any GeoJSON file, click "⬇ KML" in the export row. The downloaded file is OGC KML 2.2 — each Feature becomes a Placemark, the name property becomes the Placemark <name>, the description property becomes <description>, and the remaining properties land in <ExtendedData> as <Data name="…"><value/></Data> entries. Round-trip with the KML viewer is lossless for these fields.
TopoJSON is a topology-aware extension of GeoJSON, mostly used by D3.js. The viewer does not parse TopoJSON directly — convert it to GeoJSON first with the topojson-client CLI (npx topojson-client topo2geo or, easier, the topojson.github.io/topojson-client browser conversion). Once converted, the resulting GeoJSON drops in here cleanly.
No. Reading is done with the browser's FileReader API, parsing with JSON.parse, and rendering with MapLibre GL — all locally. The only outbound network calls are for the base map tiles (which carry the visible map area, not your data). There is no analytics on file contents and nothing is stored. You can verify this in your browser's DevTools Network tab.
RFC 7946 requires WGS84 (EPSG:4326) coordinates, in [longitude, latitude] order. If your file uses a projected CRS (UTM, State Plane, Web Mercator) the features will land in the wrong place — usually clustered near 0,0 in the Gulf of Guinea. Reproject first with QGIS (Save As → CRS: EPSG:4326), ogr2ogr (-t_srs EPSG:4326), or mapshaper. Once reprojected the file loads correctly.
Yes — click "Paste text" to expand the input area, then paste the URL into the "Fetch URL" box and click the button. The remote server must send CORS headers (Access-Control-Allow-Origin: *). GitHub raw URLs, GitHub Gists, S3 public buckets, and most public datasets work. Servers that do not send CORS headers will fail — for those, download the file locally first and use the upload button.
Two reasons. First, no I/O — the file reads in a single FileReader call and the parse is a single JSON.parse. Second, no projection step — every modern web map (including this one) draws GeoJSON directly in EPSG:4326 / Web Mercator without reprojection. Desktop GIS handles many more formats and many more CRS-es, which is great when you need it and slow when you just want to see a file.
For ingest it is permissive: the older GeoJSON spec (pre-2016) is also accepted, including files without a "bbox" field, with right-hand-rule violations, or with antimeridian crossings. For export it produces standards-compliant JSON. If you need strict RFC 7946 validation use geojsonlint.com or the @placemarkio/check-geojson library.
Data sources & methodology

Parser is the browser's native JSON.parse plus a custom validator against RFC 7946. Permissive on ingest (older GeoJSON spec accepted, antimeridian and right-hand-rule violations tolerated), strict on export. Rendering by MapLibre GL JS 5.x using a single GeoJSON source feeding four layers (fill, polygon outline, line, circle) plus a symbol layer for Point labels. Base map: OpenFreeMap Liberty — vector tiles derived from OpenStreetMap (© OSM contributors, ODbL). Nothing about your file is uploaded — files are read via FileReader, parsed locally, and rendered to MapLibre without touching a server.

More SimpleMapLab tools

KML Viewer

Open a .kml file on the map — view, inspect, convert to GeoJSON or GPX.

GPX Viewer

Drag a .gpx from Strava, Garmin, or AllTrails — tracks, waypoints, stats.

CSV to Map

Plot a CSV of lat/lng on an interactive map — color by category.

Pin Drop Map

Drop up to 100 pins with notes, colors, and CSV/GeoJSON/KML export.