A vector PMTiles viewer that works in your browser
PMTiles is a single-file format for tiled maps. One .pmtiles archive holds a whole pyramid of tiles, from the world view at zoom 0 down to street level, plus an index that says where each tile sits inside the file. Because a map app can read any tile with one HTTP range request, you can put the file on plain cloud storage and use it as a map with no tile server at all. That is why PMTiles maps are now a common way to publish OpenStreetMap data: the Protomaps basemaps and many city and country maps built with Planetiler are shipped as OpenStreetMap PMTiles files.
Looking inside one is harder. A .pmtiles file is binary, so no normal program opens it, and to see the vector tiles you usually need MapLibre, a style and some code. This PMTiles vector viewer online does the work for you. Drop a file, or paste the URL of an archive that is already online, and the viewer reads the header and directories, fetches only the tiles in view, decodes them in your browser and draws every layer in its own colour.
It is a checking tool as much as a viewer. Click any feature to read its attributes, switch layers on and off, see how large the tiles are at each zoom level, and run checks against the PMTiles v3 and vector tile specifications: header, compression, clustering, root directory size, metadata, bounds, tile counts and ETag. Then export the visible features as GeoJSON, save a PNG, or download a technical report. My advice: open the archive from its final URL before you announce it. Most "PMTiles map does not load" problems are CORS or range-request settings on the bucket, and this viewer shows them in one click.
What the vector PMTiles viewer does
Here is everything the tool does, in the order you will meet it.
- Open a file or a URL. Drag a .pmtiles file onto the map, click "Open PMTiles", or paste a URL and press Open. There is no size limit: the viewer reads only the header, the directories and the tiles it needs, from a file on your disk or from a server. "Try a sample" loads a small OpenStreetMap PMTiles file of central Paris, and the example link opens a Florence archive from pmtiles.io.
- See the map at once. The viewer reads the bounds from the header and zooms to the data. Every layer is drawn on a canvas in its own colour: polygons as light fills, lines as strokes, points as dots with labels. Layer names from the Protomaps, OpenMapTiles and Shortbread schemas, such as water, landuse, buildings, roads and places, get natural colours.
- Work with the layers. The Layers tab lists every layer from the metadata and from the tiles, with its geometry types, the number of features in a sample and all its fields with an example value. Tick layers on and off, press "Only" to see one layer alone, or click the colour square to choose your own colour.
- Click to inspect features. Click the map and a card shows every feature at that spot in the visible layers: layer, geometry type, ID and all attributes, for example the OpenStreetMap kind, name and min_zoom of a road. The feature is highlighted, and you can copy it as GeoJSON or download the whole tile as a .pbf file.
- Read the archive info. The Archive info tab shows the header and metadata in plain words: name, attribution, tile type, tile and directory compression, zoom range, bounds, center, the generator (for example Planetiler), archive size, the number of addressed and unique tiles, and the size of the directories.
- Check the tiles. The viewer reads every directory entry and gives the number of tiles, the total, average and largest size for each zoom level, and the ten largest tiles. Click "Show" to jump to a tile. The tile grid option draws every tile border with its z/x/y and stored size.
- Run the checks. The Checks tab tests the archive: header version, tile type, compression, clustering, whether the root directory fits in the first 16 KB, metadata and vector_layers, bounds and center, the zoom range and tile counts against the directories, tiles over 500 KB, deduplication, attribution and, for URLs, the ETag. Each check is marked OK, warning or error with a plain explanation.
- Share a link. When you open an archive from a URL, "Copy link to this archive" gives you a link to this page that opens the same file. Send it to a colleague and they see the same map and checks.
- Zoom past the data. Vector tiles stay sharp when you zoom in beyond the last zoom level, so the viewer keeps drawing the deepest tiles enlarged ("overzoom"). Below the first zoom level, a note tells you to zoom in.
- Export. Download the visible features as GeoJSON, the map view as PNG, the header and metadata as JSON, or a technical report with the checks, header, layers, fields, tile statistics and recommendations.
A local file is read in slices by JavaScript inside your browser tab and is never uploaded. A URL is read directly from its server by your browser; this site does not see the data.
How to view a PMTiles file, step by step
A real example with the OpenStreetMap PMTiles sample of central Paris (Protomaps basemap schema, zoom 0 to 12).

The tool opens with an empty map, a drop area and a URL field. Drag your .pmtiles file onto the map, click to choose a file, paste a URL, or press "Try a sample".

The viewer reads the header and the root directory, zooms to the bounds and draws all layers of the OpenStreetMap data: water in blue, parks in green, buildings in brown, roads in orange and place names in red.

The Layers tab lists each layer with its geometry, the features found in a sample and every field. Here only roads and water are switched on, which shows the street network and the Seine.

Click a street. The card shows its layer, geometry, ID and OpenStreetMap attributes such as kind, kind_detail and name, and the street is highlighted on the map.

The Archive info tab turns the header and metadata into plain words: tile type MVT, gzip compression, zoom 0 to 12, bounds, center, the number of tiles and the size of the directories.

The Tiles tab shows tiles and sizes per zoom level and the largest tiles, read from the directories. With the tile grid switched on, every tile border is drawn with its z/x/y and stored size.

The Checks tab tests the archive against the PMTiles v3 and vector tile rules. The sample passes every check; an archive opened from a URL also gets an ETag check.

The technical report collects the summary, a map preview, the checks, the full header, the metadata, every layer and field, the tile statistics and recommendations in one page. Print it or save it as a PDF.
How to open a PMTiles file: your options
There are several ways to open a .pmtiles file. The right one depends on whether you want to look at it, check it, or build a map with it.
- In your browser, with this viewer. The fastest way to see what is inside a vector archive, from your disk or from a URL: no install, no server, works on Windows, Mac, Linux and tablets. Best for checking an archive, reading attributes and sharing a report. For raster PMTiles (PNG, JPEG, WebP tiles) use the PMTiles Viewer on this site.
- With the pmtiles.io viewer. The official viewer by Protomaps shows the header, the metadata and a tile inspector. It is good for a quick technical look; this viewer adds layer styling, attribute fields, tile statistics, validation checks and exports.
- In MapLibre GL JS. Add the pmtiles library, register the protocol and point a vector source at pmtiles://https://example.com/file.pmtiles. With a style (for example the Protomaps basemap styles) you get a finished, fast web map. This is how most PMTiles maps are published.
- In QGIS. A QGIS build that uses GDAL 3.8 or newer opens a .pmtiles file through GDAL's PMTiles driver: Layer → Add Layer → Add Vector Layer, then choose the file. Each tile layer becomes a vector layer. Good when you want to combine the data with other GIS data.
- With the pmtiles command line tool. The go-pmtiles program prints the header ("pmtiles show"), extracts an area ("pmtiles extract"), converts from MBTiles ("pmtiles convert") and serves the archive as z/x/y tiles ("pmtiles serve").
- As MBTiles. If a tool only reads MBTiles, convert the archive with "pmtiles convert file.pmtiles file.mbtiles". The tiles inside stay the same; there is also a free MBTiles to PMTiles converter on this site for the other direction.
One thing is the same everywhere: a PMTiles archive carries data, not a style. Each app decides how to colour the layers. This viewer picks colours from the layer names so you can see the structure without writing a style first.
How the viewer reads a PMTiles archive and draws the tiles
Opening a PMTiles archive takes five steps: read the header, turn the map position into a tile ID, look the ID up in the directories, fetch the bytes with a range request, then unpack, decode and draw the tile. Here is exactly what happens, with the numbers from the Paris sample.
1. The archive layout and the 127-byte header
A PMTiles v3 archive has five sections in a fixed order. The first 127 bytes are the header: the magic word "PMTiles", the version, the offset and length of every other section, tile counts, compression, tile type, zoom range, bounds and center. The viewer reads the first 16,384 bytes with one request, which always contains the header and the root directory:
bytes 0–126 header "PMTiles" + version 3 + offsets, counts, zoom, bounds
root directory must end before byte 16,384
JSON metadata name, attribution, vector_layers, …
leaf dirs optional, for large archives
tile data the tiles, one after another
Paris sample root 127 + 142 bytes metadata 269 + 870 bytes
tile data 1,139 + 2,929,805 bytes 24 tiles, zoom 0–12
bounds 2.197266, 48.748945, 2.460938, 48.922499Coordinates are stored as integers in units of 10⁻⁷ degree, so 2.197266° is stored as 21972660. The viewer converts them back and zooms the map to the bounds.
2. From z/x/y to one tile ID: the Hilbert curve
PMTiles gives every tile in the world one number, the tile ID. All tiles of zoom 0 come first, then all of zoom 1, and so on. Inside a zoom level the tiles follow a Hilbert curve, a line that visits every tile and keeps neighbours close together:
first ID of zoom z = (4^z − 1) / 3 0, 1, 5, 21, 85, …
tile ID = first ID of zoom z + Hilbert index d(x, y)
zoom 1: 1/0/0 → 1 1/0/1 → 2 1/1/1 → 3 1/1/0 → 4
Paris 12/2074/1409
first ID of zoom 12 = (16,777,216 − 1) / 3 = 5,592,405
d(2074, 1409) = 14,248,941
tile ID = 19,841,346Because the Hilbert curve keeps nearby tiles near each other in the ID order, the tiles of one city sit close together in the file. A map that pans across a city then reads neighbouring byte ranges, which caches and CDNs handle well.
3. Directories: run-length entries and leaf directories
A directory is a sorted list of entries. Each entry says: from this tile ID, this many tiles in a row (run length) use the bytes at this offset with this length. The list is stored column by column as varints, with the tile IDs as differences, and then gzip-compressed. These are the first four entries of the Paris sample, the parents of the city tile at zoom 0 to 3:
entry tile ID run length offset length
0/0/0 0 1 0 65,269
1/1/0 4 1 65,269 76,322
2/2/1 18 1 141,591 124,909
3/4/2 75 1 266,500 116,768
stored as 24 | 0, 4, 14, 57 | 1, 1, 1, 1 | 65269, 76322, … | 1, 0, 0, …
count ID deltas run lengths lengths offsets (0 = right after the previous tile)
run length 0 → the entry points to a leaf directory, not to a tileA run length above 1 is how PMTiles stores the same tile many times for free: ten thousand identical ocean tiles become one entry. When the root directory would not fit in 16 KB, the entries are split into leaf directories and the root only points to them. To find a tile the viewer searches the root, follows at most three leaf levels and caches every directory it reads.
4. Reading only what is needed: range requests
For a URL, every read is an HTTP range request. For a local file it is a slice of the File object. Either way, opening an archive costs one read for the header and root, one for the metadata, and then one read per tile (plus a leaf directory the first time an area is visited):
GET /florence.pmtiles
Range: bytes=0-16383 → 206 Partial Content header + root
Range: bytes=525-22237 → 206 JSON metadata
Range: bytes=22238-456635 → 206 tile 0/0/0
server needs Accept-Ranges: bytes, status 206 for a range
CORS: Access-Control-Allow-Origin for your site
an ETag, so a replaced file is noticedIf the server ignores the Range header and sends the whole file with status 200, or if CORS blocks the request, the viewer says so in plain words. Those two settings are the usual reason a PMTiles map works on a laptop and fails on the web.
5. Counting the tiles: the directory scan
For the Tiles tab the viewer reads the whole root directory and, when they total 64 MB or less (8 MB for a URL), all leaf directories in one read. It expands each run and splits it by zoom level using the first ID of each zoom:
zoom of tile ID t = largest z with (4^z − 1) / 3 ≤ t tiles per zoom = Σ run lengths inside that zoom size per zoom = Σ run length × length coverage = tiles / 4^z dedupe saving = 1 − tile_contents_count / addressed_tiles_count
The totals are then compared with the three counts in the header (addressed tiles, tile entries and tile contents). A mismatch means the archive was written by a buggy tool or cut short. For planet-size archives, whose leaf directories are hundreds of MB, the scan is skipped and the map still works.
6. Unpacking and decoding the vector tile
The header says how the tiles are compressed. Gzip is unpacked with the browser's built-in DecompressionStream. The result is a Mapbox Vector Tile, a Protocol Buffers message decoded by the same decoder as the site's Vector MBTiles Viewer:
varint 300 = 1010 1100 0000 0010 → 0101100 + 0000010 × 128 = 300 zigzag 0 → 0, −1 → 1, 1 → 2, −2 → 3 n = (z >>> 1) ^ −(z & 1) command = (count << 3) | id MoveTo = 1, LineTo = 2, ClosePath = 7 9 = MoveTo 1 point 18 = LineTo 2 points 15 = ClosePath polygon ring area > 0 exterior ring, area < 0 hole
Attribute names and values are stored once per layer and each feature keeps only index pairs, which is why OpenStreetMap tiles with thousands of buildings stay around 100 to 200 KB. The decoder was tested against Mapbox's reference decoder on more than 350,000 features with no difference.
7. Drawing, overzoom and hit testing
Each map tile is a 256 × 256 pixel canvas (512 on high-resolution screens). Tile units, 0 to 4096 across, are scaled to pixels. Past the last zoom level the parent tile is enlarged and shifted. A click is converted to tile units and tested against the features:
scale = 256 × f / extent f = 2^(z_map − z_data) offset = (x mod f, y mod f) × 256 point hit if distance ≤ 7 px line hit if distance to a segment ≤ 5 px polygon hit if a ray from the click crosses the rings an odd number of times
Because the data is vector, lines are drawn again at every scale and stay sharp. Labels follow the min_zoom attribute that Protomaps and many Planetiler builds give each feature: a name appears only once the map reaches that zoom, and place names win over POI names when space is short. A quick bounding-box test skips most features before the exact click test, so even dense city tiles answer at once.
8. Tile size budget
Large tiles make maps slow: each one must be downloaded, unpacked and decoded before anything is drawn. tippecanoe limits tiles to 500 KB by default, and the same limit is widely used for vector tile services. The viewer takes every stored tile length from the directories and flags zoom levels that go over it:
stored size = length in the directory entry bytes, compressed average size = size per zoom / tiles per zoom guideline largest tile < 500 KB (512,000 bytes) Florence (pmtiles.io) largest tile 0/0/0 = 434,398 bytes → OK
In OpenStreetMap PMTiles files the largest tiles are often the low-zoom ones, which hold a whole country or continent, and the dense city centres at zoom 12 to 14. The Largest tiles list takes you straight to them.
PMTiles and the export formats in detail
What is inside a PMTiles archive, how it differs from MBTiles, and what each download from this viewer contains.
Vector PMTiles .pmtiles
A PMTiles v3 archive with tile type MVT. Each tile is a gzip-compressed Mapbox Vector Tile with named layers. The JSON metadata usually holds name, attribution, description and a vector_layers list with the fields of each layer. Archives built with Planetiler also record the build time and OpenStreetMap replication data.
metadata = {
"name": "Paris, OpenStreetMap sample",
"attribution": "© OpenStreetMap contributors",
"vector_layers": [
{ "id": "roads", "minzoom": 3, "maxzoom": 12,
"fields": { "kind": "String", "kind_detail": "String",
"name": "String", "min_zoom": "Number", … } } ]
}One file, no server, any size from a city to the whole planet. It needs a reader that supports range requests (MapLibre with the pmtiles library, OpenLayers, Leaflet plugins, QGIS or this viewer) and a style to look like a finished map.
Raster PMTiles .pmtiles
The same layout, but the tiles are images: PNG, JPEG, WebP or AVIF. The style is baked into the pixels, so the map cannot be restyled or queried, and it gets blurry past its last zoom level.
The header tile type tells them apart. This viewer sends raster archives to the PMTiles Viewer on this site, which is built for images.
PMTiles and MBTiles compared .pmtiles / .mbtiles
Both hold the same tiles. MBTiles is a SQLite database and needs a program or server that runs SQL; PMTiles is a plain file with its own index, so a browser can read single tiles over HTTP. PMTiles also deduplicates identical tiles through run lengths and orders tiles on a Hilbert curve.
Use MBTiles for editing and for tools that expect it, and PMTiles for publishing on the web. Converting between them keeps every tile byte-for-byte.
GeoJSON (view) .geojson
All features of the visible layers in the tiles that cover the current view, at the current data zoom level, as an RFC 7946 FeatureCollection in WGS84. Each feature keeps its attributes and gets _layer and _tile. Polygons are grouped with their holes.
{ "type": "Feature", "id": 35184380521390,
"properties": { "kind": "highway", "kind_detail": "motorway", "name": "Avenue de Paris",
"min_zoom": 4, "_layer": "roads", "_tile": "11/1037/705" },
"geometry": { "type": "LineString",
"coordinates": [[2.3650217, 48.7375971], [2.3645496, 48.7386726], …] } }Features are cut at tile edges, the way they are stored. One export covers at most 64 tiles; zoom in for a smaller, more detailed area. For OpenStreetMap data, check the ODbL license before you reuse an extract.
PNG (view) .png
A picture of the vector layers as they look in the map window, with a white background, a title bar with the name and zoom level, and the attribution from the metadata.
Good for documentation or a quick preview. The base map is not included, so there are no third-party image rights to worry about.
Header and metadata (JSON) .json
The full PMTiles header (offsets, lengths, counts, compression, tile type, zoom, bounds and center), the JSON metadata, the directory statistics per zoom level and the layer list found in the tiles.
Useful to compare two builds of an archive, or to copy the vector_layers list into a MapLibre style.
Tile (.pbf) .pbf
The single vector tile under your click, unpacked, exactly as MapLibre receives it. The file name holds its z/x/y.
Feed it to other tools (for example vt2geojson or a protobuf viewer) to debug one tile in detail.
Technical report .html
One HTML page with the archive summary, a map preview, every validation check, the full header table, the metadata, the layers with geometry types and fields, the tiles per zoom level, the largest tiles, recommendations and how to use the archive.
It prints cleanly to PDF. Attach it to a ticket or a delivery, so the receiver sees what is in the archive without opening it.
All exports are made in your browser from the archive you opened. Nothing is sent to this site.
Who uses a vector PMTiles viewer
PMTiles moved map hosting from tile servers to plain files, so many people now need to look inside those files.
- Web map developers. Check an archive before writing a MapLibre style: which layers exist, what the fields are called, at which zoom levels data appears. Open the production URL to confirm range requests and CORS work before going live.
- OpenStreetMap mappers and data users. Look at an OpenStreetMap PMTiles extract from Protomaps or a Planetiler build, click roads, buildings and places, and see exactly which OSM tags made it into the tiles.
- GIS analysts. Confirm that a tippecanoe, Planetiler or "pmtiles convert" output contains the right layers, attributes and zoom range, then hand it over with the report.
- DevOps and cloud engineers. Test a bucket on S3, R2 or Google Cloud Storage: the viewer shows CORS errors, missing range support and missing ETags in plain words, and the checks catch oversized tiles and unclustered archives.
- Data publishers. Verify the attribution, bounds, center and description before you publish PMTiles maps, so users get a correct credit and a correct start view.
- Offline and field mapping. Check that an archive cut with "pmtiles extract" covers the right area and zoom levels before you copy it to a device that will be out of range.
- Students and teachers. See how cloud-native maps work: switch on the tile grid, compare tile sizes across zoom levels, read the header and follow a tile ID through the directories.
- Support and bug reports. When a PMTiles map shows a gap, find the tile, download it as .pbf and attach it with the report to the ticket.
Frequently asked questions about PMTiles
The 20 questions people ask most about PMTiles files and this viewer.
1. What is a PMTiles file?
PMTiles is a single-file archive format for map tiles, made by Protomaps. It holds the tiles of every zoom level plus a compact index (the directories), so a reader can fetch any one tile with an HTTP range request. You can host it on plain static storage and use it as a map without a tile server.
2. How do I open a PMTiles file?
For a quick look, drop it into this viewer or paste its URL: nothing is installed or uploaded. To build a web map, use MapLibre GL JS with the pmtiles protocol. QGIS opens it as a vector layer when it uses GDAL 3.8 or newer. The pmtiles command line tool prints the header and converts it to MBTiles. The section "How to open a PMTiles file" above compares all options.
3. Is this PMTiles viewer free?
Yes. It is free, with no account, no daily limit and no watermark on the exports. Everything runs in your browser, so there is no server cost to pass on.
4. Is my file uploaded?
No. A local file is read in slices with the browser's File API, and the tiles are decoded and drawn inside your tab. When you open a URL, your browser fetches the parts directly from that server; this site never receives the data. Only a base map, if you switch one on, is loaded from its provider.
5. How big can the archive be?
There is no fixed limit. The viewer never loads the whole file, only the header, the directories and the tiles in view, so a several-GB planet archive opens as fast as a small one. For very large archives the per-zoom tile statistics are skipped, because their directories alone are hundreds of MB.
6. Why does my PMTiles URL not open?
Almost always it is CORS or range requests. The server must answer cross-site requests from your page (an Access-Control-Allow-Origin header) and must return only the requested bytes with status 206. Cloud buckets need a CORS rule for GET and HEAD; some CDNs need byte-range caching switched on. The error message in the viewer tells you which of the two failed.
7. What are OpenStreetMap PMTiles?
PMTiles files built from OpenStreetMap data, such as the Protomaps basemap (layers earth, water, landuse, landcover, roads, buildings, pois, places, boundaries, transit) or OpenMapTiles-schema builds from Planetiler. You can download daily planet builds or extract a region. They are under the ODbL license and need the credit "© OpenStreetMap contributors".
8. What is the difference between PMTiles and MBTiles?
Both store the same tiles. MBTiles is a SQLite database that needs a program or tile server to read; PMTiles is a plain file with its own index that a browser can read over HTTP. PMTiles also stores identical tiles once. Convert between them with "pmtiles convert" or this site's MBTiles to PMTiles converter, and the tiles stay the same.
9. Can I view raster PMTiles here?
This page is for vector tiles. If you open a raster archive (PNG, JPEG, WebP or AVIF tiles), the viewer recognises it from the header and links you to the PMTiles Viewer on this site, which displays image tiles.
10. What does "clustered" mean?
A clustered archive stores the tiles in tile ID order, so tiles that are close on the map are close in the file. Readers can then fetch neighbours together, and CDN caches work better. Archives written by "pmtiles convert", tippecanoe and Planetiler are clustered.
11. Why must the root directory fit in 16 KB?
So that one request for the first 16,384 bytes always returns the header and the root directory together. A reader then knows where every tile or leaf directory is after a single round trip. If the root is larger, the spec is broken and many readers fail. The Checks tab tests this.
12. What is a tile ID?
One number for each tile in the world. All zoom 0 tiles come first, then zoom 1, and so on; within a zoom level the tiles follow a Hilbert curve. Tile 12/2074/1409 in Paris, for example, has ID 19,841,346. The directories map these IDs to byte ranges.
13. What is deduplication in PMTiles?
Many tiles are identical, for example open ocean or empty land at high zoom. PMTiles stores such a tile once and lets many tile IDs point to it, using run lengths for long stretches. The header counts addressed tiles and unique tile contents; the viewer shows how much space this saves.
14. What does overzoom mean?
A tileset has a last zoom level, often 14 or 15 for OpenStreetMap data. When you zoom in further, the viewer keeps using those tiles and draws them larger. Because vector data is redrawn, lines stay sharp. This is why basemaps rarely go past zoom 15.
15. Why are features cut at tile edges?
Each vector tile only holds the parts of features inside it plus a small buffer. A long road is stored as several pieces, one per tile, and a renderer draws them side by side so the cut is invisible. In the GeoJSON export the pieces stay separate, each with a _tile attribute.
16. Can I convert PMTiles to GeoJSON?
For an area, yes: zoom to it and press "GeoJSON (view)". It exports the visible layers from up to 64 tiles. For a whole archive, export from the original data instead, because tiles are simplified and cut at the edges.
17. Can I edit a PMTiles file here?
No, the viewer only reads. To change the data, edit the source and build the archive again with tippecanoe or Planetiler. To change only the metadata, use "pmtiles edit" from the command line tool.
18. Which tools make vector PMTiles?
tippecanoe (from GeoJSON, CSV and FlatGeobuf), Planetiler (from OpenStreetMap, including the Protomaps and OpenMapTiles schemas), GDAL 3.8 and newer, and "pmtiles convert" from an MBTiles file. The Archive info tab shows the generator when the metadata records it.
19. What is MLT and why is it not shown?
MLT (MapLibre Tile) is a newer vector tile format with columnar encoding and better compression. PMTiles can store it with tile type 6. This viewer decodes Mapbox Vector Tiles (MVT) only and tells you when an archive holds MLT; MapLibre GL JS can display those archives.
20. Does it work on a phone or tablet?
Yes, in any current browser on iOS, Android, Windows, macOS and Linux. Opening from a URL works especially well on phones, because only the tiles in view are downloaded. Use the fullscreen version for more room.
Specifications, software and data credits
The viewer is built on open specifications, open software and open data:
- PMTiles (Protomaps) · BSD-3-ClausePMTiles v3 specification and the pmtiles JavaScript library by Protomaps: the archive layout, Hilbert tile IDs, directories, and reading the header, directories and tiles from a file or URL.
- Mapbox Vector Tile Specification · SpecificationMapbox Vector Tile specification: the protobuf layout, geometry commands and winding rules that the decoder follows.
- Leaflet 1.9 · BSD-2-ClauseInteractive map and the canvas grid layer that draws the tiles.
- OpenStreetMap · ODbL 1.0Map data in the Paris sample and the Florence example: © OpenStreetMap contributors, under the Open Database License.
- Protomaps Basemap and pmtiles.io · BSD-3-Clause / ODbLBasemap schema of the sample, and the Florence example archive on pmtiles.io.
- Protomaps (hosted by KONAKTIVE), CARTO, OpenStreetMap, Esri World Imagery · ODbL and provider termsOptional base maps: own vector tiles hosted by KONAKTIVE with CARTO and OpenStreetMap as fallback, and Esri World Imagery.
The directory scan, the vector tile decoder, the renderer, the checks and all exports were written for this site and run entirely in your browser.
Related tile and GIS file tools
The checks follow the PMTiles v3 and Mapbox Vector Tile 2.1 specifications and common practice; a passed check does not guarantee that every map app will accept the archive. Sample data © OpenStreetMap contributors (ODbL), Protomaps. Optional base maps © OpenStreetMap contributors, drawn with Protomaps (hosted by KONAKTIVE), with CARTO as the fallback. Satellite imagery: Esri.
