GeoJSON Viewer

Upload or paste GeoJSON to visualize on an interactive map. See feature counts, geometry types, properties table. Runs in your browser.

1.0.0
Version
Auth
Batch

About GeoJSON Viewer

Open a .geojson file in a text editor and you get a wall of brackets and coordinate pairs — useless for confirming whether the feature you exported from QGIS actually covers the right block, or whether a colleague's polygon set has the right winding order, or whether the API endpoint you just hit returned reasonable geometry. The official path is to install QGIS or open Mapbox Studio, both of which are full GIS environments — overkill when the question is just "does this render?".

This GeoJSON viewer drops a file or pasted blob onto an interactive Leaflet map with OpenStreetMap tiles — no API key, no account, no upload. Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon and GeometryCollection all render with sensible default styling. The map auto-zooms to the bounding box of the feature collection so you don't have to pan to find your data. Click any feature to see its properties in a popup, or open the properties table below the map for a sortable, filterable view across all features. Geometry-type pills at the top give you a quick breakdown: '472 Polygon, 13 MultiPolygon, 8 LineString'. Everything — parsing, rendering, property inspection — runs as JavaScript in the page, so confidential boundaries, internal datasets, or anything you wouldn't paste into a public API stay on your machine.

Use it to sanity-check an export from QGIS, ArcGIS or PostGIS before shipping it to a teammate, debug a coordinate-order bug (lon-lat vs lat-lon is the classic), preview the output of a tippecanoe or ogr2ogr pipeline, audit a property set across hundreds of features, or share a quick render with someone who doesn't have a GIS desktop. Files up to roughly 10 MB or 20 k features render smoothly; for larger datasets, downstream tools like QGIS or vector tiles are the right answer.

GeoJSON Viewer Use Cases

  • GIS analysts sanity-checking a QGIS or ArcGIS export before handing it off
  • Developers debugging a coordinate-order bug (lon-lat vs lat-lon mixups)
  • Data engineers previewing tippecanoe, ogr2ogr or PostGIS query outputs
  • Auditing property keys across hundreds of polygons before joining to a CSV
  • Sharing a feature set with a non-GIS colleague who just needs to see the shape
  • Verifying the bounding box of a public dataset (Natural Earth, US Census, OSM extract)
  • Inspecting confidential boundaries without uploading them to a third-party API

GeoJSON Viewer Features

  • Renders Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon and GeometryCollection on a Leaflet map
  • Auto-zooms to the feature collection's bounding box so you land on your data rather than the equator
  • Properties table below the map is sortable and filterable across every feature in one scrollable view
  • Geometry-type breakdown pills show the count per type at a glance (e.g. '472 Polygon, 13 MultiPolygon, 8 LineString')
  • Click any feature for a popup with its full properties dictionary, including nested objects rendered as JSON
  • Drop a file or paste GeoJSON text into the textarea — both accept FeatureCollection, Feature and bare geometry inputs
  • Parsing, rendering and inspection run as JavaScript in your browser — geometry never uploads, only OSM tile requests go out

How to Use GeoJSON Viewer

Drop a file or paste GeoJSON

Switch to the Upload tab and drag a .geojson or .json file onto the upload zone, or switch to the Paste tab and paste a FeatureCollection, single Feature or bare geometry into the textarea. The Load sample button populates a starter dataset if you just want to try it.

Click Render on Map

The viewer parses the JSON, validates it as GeoJSON, computes the bounding box, and draws every feature on the Leaflet map. The map auto-zooms so your data fills the viewport — no manual pan needed.

Inspect the geometry-type pills

The pills above the map show the count of each geometry type in the file. Useful for spotting a polygon set that secretly mixes in some LineStrings or a MultiPoint where you expected Points.

Click a feature for its properties

Click any drawn feature on the map to see a popup with its properties dictionary — keys on the left, values on the right, nested objects rendered as JSON. Useful for verifying the right rows landed at the right shapes.

Or scan the properties table

Below the map, the properties table lists every feature with its geometry type, id and property values across all columns. Filter by typing a property name or value — great for finding the one outlier feature with a missing name.

GeoJSON Viewer FAQ

Your geometry data does not. Parsing, validation and rendering all happen as JavaScript on the page, and nothing about your features is sent to a server. The only outbound network traffic is OpenStreetMap tile requests, which carry the map viewport (a zoom level and a tile coordinate) but not your features. For maximum paranoia, use the browser DevTools Network tab to confirm.

All seven RFC 7946 types: Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon and GeometryCollection. Both FeatureCollection (the usual shape) and bare Feature or geometry inputs are accepted — the parser wraps single features into a one-element collection for consistent rendering.

Up to roughly 10 MB or 20,000 features renders smoothly in a typical browser. Beyond that, the Leaflet canvas can stutter on pan and click — for those scales, switch to QGIS, kepler.gl with WebGL, or build a vector-tile pipeline via tippecanoe + Mapbox or Maputnik. The viewer will still load larger files, but interaction may slow down.

geojson.io is the classic editor with drawing tools and GitHub gist sharing — heavier UI focused on creating GeoJSON. QGIS is a full desktop GIS. This viewer is the narrowest version of the task — drop a file, see it on a map, inspect properties, done. Use it when you don't want to upload to a third-party editor or install a 700 MB desktop app for a one-minute visual check.

Lightly. The viewer requires a valid JSON document, a recognised top-level type (FeatureCollection, Feature, or a bare geometry) and at least one well-formed coordinate. Beyond that it's permissive — it will render features even if a few have invalid coordinates or unusual property shapes. For strict RFC 7946 conformance checking, use geojsonhint or the validator on geojson.io.

Not directly — only .geojson and .json. TopoJSON requires topology decoding (a small different library), and shapefiles are a multi-file binary format. To use either, convert to GeoJSON first with ogr2ogr (shp → geojson), the mapshaper.org browser tool, or the topojson-server JavaScript package. Then drop the result here.

OpenStreetMap raster tiles served from the standard tile endpoint, with proper © OpenStreetMap attribution. No API key is required and there is no usage cap for casual viewing. If your dataset covers a region without good OSM coverage you may see thin tiles — that's an OSM data characteristic, not a viewer issue.

Zero uploads. GeoJSON is parsed and rendered entirely in your browser. Tiles come from OpenStreetMap.

Upload .geojson or .json file

Drop here or click to browse

GeoJSON Viewer Tutorial

What is GeoJSON?

GeoJSON is the standard format for exchanging geographic features — points, lines, polygons, with arbitrary properties. Used by mapping libraries (Mapbox, Leaflet, Google Maps), GIS tools (QGIS, ArcGIS), and data sources (Natural Earth, OpenStreetMap, US Census).

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "geometry": {"type": "Point", "coordinates": [-73.98, 40.75]},
      "properties": {"name": "Times Square"}
    }
  ]
}

Supported Geometry Types

  • Point / MultiPoint — single or multiple coordinates
  • LineString / MultiLineString — roads, rivers, routes
  • Polygon / MultiPolygon — countries, parcels, buildings
  • GeometryCollection — mixed geometries in one feature

Common Use Cases

  • Quick sanity check on a GeoJSON file — does it actually render?
  • Review feature properties across hundreds of polygons
  • Debug coordinate ordering (lon-lat vs lat-lon mixups)
  • Share a feature set with someone who doesn't have QGIS installed
  • Verify bounding box before importing to a production system

Interactive Map

  • Click any feature to see its properties in a popup
  • Map auto-zooms to fit the bounding box
  • OpenStreetMap tiles — no API key needed
  • Uses Leaflet, loaded from unpkg CDN (no data sent anywhere from our side)

Limits

Client-side rendering means very large files (>10MB, >20k features) may stutter. For those, use desktop tools like QGIS or Mapbox Studio.