MapToolkit.org: Free Vector Basemaps for Custom Map Websites

18th November 2026 · mapping, maplibre, gis

MapToolkit.org is a free vector tile basemap service. You pick a style URL, hand it to MapLibre GL JS (or Leaflet, OpenLayers, deck.gl, CesiumJS and several mobile SDKs), and your visitors’ browsers fetch the tiles, glyphs and sprites directly. No API key. No account. No usage bill. No tile server to run. Seven published styles cover summer, winter, street, light, dark, cycling and hiking, each with 3D terrain and language variants. If none of them fit, MapMaker edits any style in the browser and exports a style.json you host yourself.

The tiles are free under a Community License.

This post walks through three map website patterns with concrete code examples, then compares the free community stack against a commercial hosted map API on the dimensions that matter when you are shipping a site.

The Traditional Stack vs MapToolkit.org

Consider a local events website that plots ride meetups on a map and lets visitors switch between a street view and an outdoor view. The traditional architecture looks something like this:

graph TD
    A[Your GeoJSON] -->|Load into SDK| B[Map SDK + API Key]
    B --> C[Commercial Tile API]
    C --> D[Website Map]
    B --> E[Usage Billing]
    B --> F[Quota Alerts]
    B --> G[Key Restrictions]

That is an account to create, a key to rotate, domain restrictions to maintain, a billing threshold to watch, and a quota dashboard to check when the map suddenly goes blank. Now the same system on MapToolkit.org:

graph TD
    A[Your GeoJSON] --> B[MapLibre GL JS]
    B -->|Style URL| C[MapToolkit.org Tiles]
    B --> D[Website Map]

The basemap becomes a URL. Your data stays in your own GeoJSON file or API. Here is what that looks like in code.

Traditional Approach: Commercial Map API + Key

The map initialisation needs an access token kept out of source control:

// src/map.js - commercial hosted map
import mapboxgl from 'mapbox-gl';

mapboxgl.accessToken = import.meta.env.VITE_MAPBOX_TOKEN;

const map = new mapboxgl.Map({
  container: 'map',
  style: 'mapbox://styles/mapbox/streets-v12',
  center: [144.9631, -37.8136],
  zoom: 12,
});

Your own data is added as a source and layer after the map loads:

map.on('load', () => {
  map.addSource('meetups', {
    type: 'geojson',
    data: 'https://example.com/api/meetups.geojson',
  });

  map.addLayer({
    id: 'meetup-points',
    type: 'circle',
    source: 'meetups',
    paint: {
      'circle-radius': 7,
      'circle-color': '#f43f5e',
      'circle-stroke-width': 2,
      'circle-stroke-color': '#ffffff',
    },
  });
});

That is a workable pattern, but the token is now part of your deployment. It needs a referrer restriction, a rotation policy and a billing alert. Switching to a second style means learning another vendor URL scheme. If the site goes quiet for a year and then gets a traffic spike, you find out what the usage bill looks like after the fact.

MapToolkit.org Approach: A Style URL

The whole setup is a style URL plus the standard map controls:

<!doctype html>
<html>
<head>
  <link href="https://cdn.jsdelivr.net/npm/maplibre-gl@6.16.0/dist/maplibre-gl.css" rel="stylesheet" />
  <link href="https://cdn.jsdelivr.net/npm/@maptoolkit/maplibre-logo-control@1.0.0/dist/maplibre-logo-control.css" rel="stylesheet" />
  <style>
    html, body { margin: 0; padding: 0; height: 100%; }
    #map { width: 100%; height: 100%; }
  </style>
</head>
<body>
  <div id="map"></div>
  <script type="module">
    import * as maplibregl from 'https://cdn.jsdelivr.net/npm/maplibre-gl@6.16.0/dist/maplibre-gl.mjs';
    import { LogoControl } from 'https://cdn.jsdelivr.net/npm/@maptoolkit/maplibre-logo-control@1.0.0/+esm';

    const map = new maplibregl.Map({
      container: 'map',
      style: 'https://styles.maptoolkit.org/summer.json',
      center: [144.9631, -37.8136],
      zoom: 12,
      attributionControl: { customAttribution: '', compact: false },
    });

    map.addControl(new LogoControl());
  </script>
</body>
</html>

LogoControl and the attributionControl option are the standard MapToolkit setup; the docs cover the details if you need them.

Adding your own data is the same MapLibre code as before, just without the token:

map.on('load', () => {
  map.addSource('meetups', {
    type: 'geojson',
    data: 'https://example.com/api/meetups.geojson',
  });

  map.addLayer({
    id: 'meetup-points',
    type: 'circle',
    source: 'meetups',
    paint: {
      'circle-radius': 7,
      'circle-color': '#f43f5e',
      'circle-stroke-width': 2,
      'circle-stroke-color': '#ffffff',
    },
  });
});

There is no account to configure and no key to leak. The style URL works the same way in every MapLibre-compatible library, so moving from a vanilla page to React or Svelte changes the wrapper, not the basemap.

Use Case 1: A Local Events Map with a Style Switcher

For the events site, letting visitors choose between Street and Hiking needs one plugin. The control defaults to bottom-left, so put it in a different corner where its panel will not cover other map controls. The built-in styles are the seven community styles, so there is no configuration and no API key.

There is one catch: calling setStyle discards every source and layer on the map, including the meetups layer you added yourself. Re-add your own layers on the next styledata event. Here is the complete integration:

import { StyleControl } from '@maptoolkit/maplibre-style-control';
import '@maptoolkit/maplibre-style-control/style.css';

map.addControl(new StyleControl(), 'top-left');

function addMeetupLayer() {
  if (map.getSource('meetups')) return;

  map.addSource('meetups', {
    type: 'geojson',
    data: 'https://example.com/api/meetups.geojson',
  });

  map.addLayer({
    id: 'meetup-points',
    type: 'circle',
    source: 'meetups',
    paint: { 'circle-radius': 7, 'circle-color': '#f43f5e' },
  });
}

map.on('styledata', addMeetupLayer);

Visitors get a basemap switcher and your markers survive the switch. If the site is built with Leaflet instead, the same style URL loads through the maplibre-gl-leaflet plugin.

Use Case 2: A Trail Planner with Terrain and an Elevation Profile

Every community style has a -3d variant with terrain already configured. For a trail planner, swap hiking.json for hiking-3d.json and tilt the map. The elevation model is terrarium-encoded raster DEM, not Mapbox Terrain-RGB. That matters if you decode it yourself, but the -3d style handles it for you. You cannot combine -3d with a language suffix, so hiking-3d-de.json returns a 404. If you need both, start from the -3d style and override the label layers in your own hosted JSON.

For the route profile, the Elevation Control plugin draws a profile from a GeoJSON line and links hovering on the profile to the route on the map. The route must carry its own heights: every coordinate needs a third value, [lng, lat, ele], in metres. The community services do not run an elevation lookup, so a track recorded with a GPS device works and a bare LineString will not. If you need heights looked up server-side, that is a separate paid API. Here is the full setup:

import { ElevationControl } from '@maptoolkit/maplibre-elevation-control';
import '@maptoolkit/maplibre-elevation-control/style.css';

const map = new maplibregl.Map({
  container: 'map',
  style: 'https://styles.maptoolkit.org/hiking-3d.json',
  center: [11.389, 47.29],
  zoom: 12,
  pitch: 60,
  bearing: -20,
  attributionControl: { customAttribution: '', compact: false },
});

const route = await fetch('/routes/alpine-loop.geojson').then(r => r.json());

// Keep the profile clear of the map's bottom corner.
map.addControl(new ElevationControl(route), 'top-right');

Two details make this pattern worth choosing over bolting a DEM onto a commercial map: the trail style already carries waymarked route shields, SAC grades and hillshade passes, and the plugin is BSD 3-Clause rather than a black box you have to invoice for.

Use Case 3: A Brand-Styled Store Locator with MapMaker

A retail locator often needs the basemap to sit inside a brand palette rather than fight it. MapMaker edits any published style in the browser with three levels of control:

  • Easy Mode - sliders and switches for palette, label density, terrain, and feature groups such as roads, water, buildings and points of interest. No JSON.
  • Photo-to-Map - upload a logo or mood-board image and MapMaker derives a palette from it.
  • Expert Mode - the underlying MapLibre style.json with live validation. Click a feature on the map to jump to the layer that draws it.

Export the result and host the JSON anywhere. Nothing needs registering with Maptoolkit. Visitors’ browsers fetch the tiles, glyphs and sprites that the style references. A shorter route is to fork a published style from github.com/maptoolkit/maptoolkit.org and change only what you need. Cycling carries 134 layers and Hiking 132; a city locator will never draw most of them, so deleting unused layers leaves less JSON to parse and less work per frame.

Two constraints are worth knowing before you commit to a design. The glyph endpoint serves about 280 faces across 20 families, including serif, slab, display and monospace, but you cannot upload a brand typeface without hosting your own glyphs and repointing the style’s glyphs property. You can add your own icons: keep the existing icons.maptoolkit.org sprite URLs and append yours, rather than replacing them and dropping every built-in icon.

Point the map at your exported style, then add store markers with a shared popup:

const map = new maplibregl.Map({
  container: 'map',
  style: 'https://example.com/styles/brand-light.json',
  center: [144.9631, -37.8136],
  zoom: 11,
  attributionControl: { customAttribution: '', compact: false },
});
map.addControl(new LogoControl());

const popup = new maplibregl.Popup({ offset: 25 });

stores.forEach((store) => {
  popup.setHTML(`<strong>${store.name}</strong><br>${store.address}`);

  new maplibregl.Marker({ color: '#f43f5e' })
    .setLngLat([store.lng, store.lat])
    .setPopup(popup)
    .addTo(map);
});

Restyle the basemap as much as you like, but keep your own controls out of the bottom corners. Check the result at a narrow viewport and after a drag or two.

Hosting, Licensing and Limits

A few details are easy to miss until you are in production:

  • Reference the TileJSON, not a tile URL. Tiles sit behind a dated path that changes when the data is rebuilt. A source with "url": "https://tiles.maptoolkit.org/mtk.json" follows the current path; a hard-coded tiles array will eventually stop returning tiles.
  • Exported styles are snapshots. A style downloaded from MapMaker does not receive future updates the way styles.maptoolkit.org styles do. You own the hosting and the maintenance.
  • Rate limits exist. Unregistered traffic gets 120 tiles per second sustained and 200 in burst per website, with a 40 tiles per second cap per visitor IP. Cached tiles do not count. There is no SLA on the community service.
  • The tile server is not open source and is not self-hostable. What is public: the seven styles and variants under the Community License, the Maps SDK under BSD-3-Clause, and the plugins under MIT.

Those constraints are the real cost of the service. For most content sites, a free, good-looking basemap is a good trade.

Traditional Map Hosting vs MapToolkit.org: Comparison

Dimension Commercial Map API MapToolkit.org
Access Account, API key, domain restrictions Style URL, no key or sign-up
Cost Usage-based billing, quota monitoring Free community service under the Community License
Styling Vendor style editor and URL scheme Seven published styles, MapMaker, or your own style.json
Your own data GeoJSON sources in the vendor SDK Same MapLibre source and layer API, no token
Fonts and icons Vendor set, own glyphs are limited 280 glyph faces, own sprites alongside the defaults, no font uploads
Reliability Contractual SLA and support Community service, no SLA, published rate limits
Self-hosting Usually not available Tiles not self-hostable; styles are yours to host
Compatibility Tied to one SDK family MapLibre-compatible libraries plus Leaflet and OpenLayers plugins
Browser SDK Vendor SDK version MapLibre GL JS 4.2+ for basic styles, 5.6+ for color-relief styles

The commercial API wins on guarantees, support and fully controlled branding. MapToolkit.org wins when a good-looking, fast, styleable basemap is all you need and you are happy to work within the Community License.

Practical Takeaways

Use MapToolkit.org when the map is content rather than a product surface: event listings, travel guides, store locators, trail pages, dashboards with a few markers. The zero-key setup removes a chunk of deployment work, the styles are genuinely good out of the box, and MapMaker gets you a branded cartography without a design-to-JSON pipeline. Small teams and static sites benefit most because there is no backend to build at all.

Stick with a commercial map API when the map is business-critical and needs a contractual SLA, dedicated support, self-hosting, or a fully controlled brand treatment including your own typeface. If a blank map during a billing incident would cost more than the licence fees, pay for the licence. The community service publishes rate limits precisely because it is a community service.

The pragmatic pattern is to start with a published style URL and ship the map in an afternoon, then move to a forked or MapMaker-exported style when the design needs it. Keep your own data in GeoJSON sources that survive a style change and keep custom controls out of the bottom corners. If the project later needs an SLA, the MapLibre code you wrote transfers to a hosted style URL with a key - only the style line changes.

The Bottom Line

The basemap under a website is plumbing. It has to be there, it has to look right, and nobody visits a site for the tiles. MapToolkit.org removes the account, the key, the bill and the tile server from that plumbing, and leaves you with a style URL.

That trade pays off for the long tail of map websites: the tournament fixture page, the cafe guide, the council consultation map, the personal travel blog. For those sites, the alternative is an API key you forgot to rotate and a style you cannot quite make match the rest of the page. For a high-traffic commercial product with a brand system and an ops team, the missing SLA is a real reason to keep paying.

The trade-off is real. The service is free because it is a community service, there is no SLA, and the tiles cannot be self-hosted. But when the map stops being the hard part of the build, you notice.

The data you put on the map matters more than the tiles underneath it, but when the tiles stop getting in the way, you notice.

References and Documentation