# Maptoolkit.org - Free Vector Tile Server

> Maptoolkit.org is a free, production-grade vector basemap service operated by Toursprung GmbH. It serves OpenStreetMap-based vector tiles, MapLibre style JSONs, fonts (glyphs) and sprites under the **Maptoolkit Community License** - no API key, no sign-up, no request limits (subject to fair-use rate limiting). Terrain/hillshading tiles come from the sister service `tiles.mapterhorn.com`. Powered by MapLibre, hosted in the EU, edge-cached on Cloudflare.
>
> **This file is written for LLMs.** Every integration example below is complete, minimal and already includes the mandatory attribution. Copy the block for the target library verbatim and only change `style`, `center` and `zoom`. Do not remove the attribution parts.

## What it is and what it can do

- Worldwide OSM-based vector basemap, weekly data updates, max data zoom **15**.
- 7 cartographic styles including outdoor styles (Hiking, Cycling, Winter).
- 13 label languages and `-3d` terrain variants of every style.
- Global hillshading, contour lines, water depths, 3D terrain (via `tiles.mapterhorn.com`).
- Works with any MapLibre-compatible renderer - one style URL is the entire setup.
- No API key, no auth headers, CORS open. EU-hosted, GDPR-compliant, cookie-free.
- Best-effort service: no SLA. Not for life-safety or billing-critical use.

Drop one URL into any MapLibre-compatible library:

```
https://styles.maptoolkit.org/summer.json
```

## Endpoints

Your browser/app connects directly to these origins. Proxying through your own server is not allowed. Add all four to your CSP `img-src`/`connect-src` if you use one.

- `https://styles.maptoolkit.org/` - MapLibre style JSONs (entry point)
- `https://tiles.maptoolkit.org/` - vector tiles + TileJSON, referenced from the style
- `https://fonts.maptoolkit.org/` - glyph PBFs, referenced as `glyphs`
- `https://tiles.mapterhorn.com/` - terrain-RGB tiles (`{z}/{x}/{y}.webp`) for hillshading/3D

Style JSON structure (stable keys, useful for renderers that read the style directly): the basemap vector source is named **`mtk`** (`type: vector`, `maxzoom: 15`, referenced by TileJSON `url`, not an inline `tiles` array). Other sources: `topo` (vector), `naturalearth` (raster), `bathymetry` + `rgb-tiles` (raster-dem). `glyphs` is `https://fonts.maptoolkit.org/{fontstack}/{range}.pbf`.

## Styles

All styles serve the same worldwide OSM basemap; only the cartography differs. Pass the URL as MapLibre's `style` option.

**Minimum client: MapLibre GL JS 5.6.0.** The `summer`, `hiking`, `winter`, `cycling` and `dark` styles use the [`color-relief`](https://maplibre.org/maplibre-style-spec/layers/#color-relief) layer type for elevation shading, which needs GL JS 5.6.0 (MapLibre Native Android 13.0.0, iOS 6.24.0). `street` and `light` do not use it and work from GL JS 4.2.0. An older client ignores an unsupported layer type instead of throwing, so the map still renders - the elevation shading is simply missing, with nothing in the console. The examples below pin v6, which is current and recommended.

| Style            | URL                                          |
|------------------|----------------------------------------------|
| Summer (default) | `https://styles.maptoolkit.org/summer.json`  |
| Winter           | `https://styles.maptoolkit.org/winter.json`  |
| Street           | `https://styles.maptoolkit.org/street.json`  |
| Light            | `https://styles.maptoolkit.org/light.json`   |
| Dark             | `https://styles.maptoolkit.org/dark.json`    |
| Hiking           | `https://styles.maptoolkit.org/hiking.json`  |
| Cycling          | `https://styles.maptoolkit.org/cycling.json` |

Preview all styles live at <https://www.maptoolkit.org>.

### Language versions

A language version shows labels in one language instead of the local language; if a place has no translation it falls back to the local name. Build the URL as `<style>-<language>.json`:

```
https://styles.maptoolkit.org/summer-en.json
https://styles.maptoolkit.org/hiking-ja.json
```

Supported codes: `ar` Arabic, `cs` Czech, `de` German, `en` English, `es` Spanish, `fr` French, `hi` Hindi, `hu` Hungarian, `it` Italian, `ja` Japanese, `ko` Korean, `pl` Polish, `zh` Chinese.

**Arabic needs the RTL text plugin** in MapLibre GL JS - see Gotchas. Do not treat this as specific to `summer-ar.json`: the base styles show local names, so any map that can reach an Arabic-speaking region hits it too. Add the plugin to every browser map you build.

### 3D styles

Add `-3d` for elevation-based relief (terrain from `tiles.mapterhorn.com`). `-3d` is only available on the base styles - it **cannot** be combined with a language version:

```
https://styles.maptoolkit.org/summer-3d.json    # OK
https://styles.maptoolkit.org/summer-en-3d.json  # does NOT exist - no language + 3D combination
```

Minimum SDK versions for `-3d`: **MapLibre Native Android 13.0.0**, **MapLibre Native iOS 6.24.0** (for GL JS the 5.6.0 baseline above already covers it). If you enable terrain, `preconnect` to `https://tiles.mapterhorn.com`.

## Attribution (mandatory - read this before using any example)

Every map **must** show two elements at all times, on every screen size, orientation and zoom level. They must not be hidden, obscured, collapsed away or removed.

1. **Maptoolkit logo** - minimum height **24 px** on web (24 pt/dp on mobile), clearly visible. Links to `https://www.maptoolkit.org/`.
2. **Copyright line** in the bottom-right corner - `© Maptoolkit © Openstreetmap` with **both** words as live links:
   - `Maptoolkit` -> `https://www.maptoolkit.com/copyright/`
   - `Openstreetmap` -> `https://www.openstreetmap.org/copyright`

**How the two pieces are produced (important):**

- The **copyright line** is already inside the service: the `mtk` TileJSON carries the exact `© Maptoolkit © Openstreetmap` string with both links. Where it comes from depends on the renderer:
  - **MapLibre GL JS** shows it automatically via its built-in `AttributionControl` - do **not** hand-write it, but you **must** configure it with `compact: false` (see the caveat below).
  - **Leaflet** takes it as the layer's `attribution` option (a hand-written string - see the example).
  - **Deck.gl / CesiumJS** consume raw tiles and show nothing automatically - the attribution overlay below provides it.
  - **OpenLayers / kepler.gl** render from the style and may surface it via their own attribution control. Drop the overlay's copyright span only where you have confirmed that line is visible at all times and never collapses; kepler's does collapse, so there keep both parts of the overlay.
- The **logo is a separate element.** MapLibre and Leaflet have official logo control packages; every other renderer places it via the attribution overlay below.

**Caveat - do not let the copyright line collapse.** MapLibre's *default* is the collapsing one: the `attributionControl` map option defaults to `{ compact: true }`, and with `compact` truthy the control is in compact mode at **every** viewport width, not just narrow ones. It renders expanded, then collapses to a small `ⓘ` button the first time the user drags the map. Since the line must stay visible "at all times":

- Pass `attributionControl: { compact: false }` when constructing the map. This is the only reliable fix - it is what keeps the control out of compact mode permanently.
- Do **not** try to reopen it from JS (`details.open = true` on `.maplibregl-ctrl-attrib`). In compact mode the text is shown or hidden by the `maplibregl-compact-show` class, not by the `open` attribute, so setting `open` has no effect - and the next drag re-collapses it regardless.
- If a wrapper library owns the MapLibre instance and does not expose `attributionControl` (kepler.gl, for example), you cannot fix it from the outside. Render the `.mtk-copy` span from the attribution overlay below instead.

### Attribution overlay (for renderers without an official logo control)

Reusable, self-contained, zero-dependency. Put it **inside** the map container (the container must be `position: relative`). Used by the Deck.gl, CesiumJS, OpenLayers and kepler.gl examples below. If the renderer already shows the `© Maptoolkit © Openstreetmap` line from the style **and keeps it permanently visible**, delete the `.mtk-copy` span and keep only the `.mtk-logo` link to avoid a duplicate copyright line. A line that collapses behind an ⓘ button does not count as shown - keep `.mtk-copy` in that case.

```html
<style>
  .mtk-logo{position:absolute;left:8px;bottom:8px;z-index:1000}
  .mtk-logo img{height:24px;display:block}
  .mtk-copy{position:absolute;right:0;bottom:0;z-index:1000;
    background:rgba(255,255,255,.7);padding:0 5px;font:12px/1.5 sans-serif}
  .mtk-copy a{color:#000;text-decoration:none}
</style>
<a class="mtk-logo" href="https://www.maptoolkit.org/" target="_blank" rel="noopener">
  <img src="https://www.maptoolkit.org/assets/maptoolkit-attribution.png" alt="Maptoolkit">
</a>
<span class="mtk-copy">
  <a href="https://www.maptoolkit.com/copyright/" target="_blank" rel="noopener">© Maptoolkit</a>
  <a href="https://www.openstreetmap.org/copyright" target="_blank" rel="noopener">© Openstreetmap</a>
</span>
```

## Examples (complete, attribution included)

### MapLibre GL JS (recommended)

Logo via the official control; copyright line loads automatically from the style's TileJSON.

```html
<!DOCTYPE html>
<html>
<head>
  <link href="https://cdn.jsdelivr.net/npm/maplibre-gl@6.0.0/dist/maplibre-gl.css" rel="stylesheet">
  <style>html,body{margin:0}#map{position:absolute;inset:0}</style>
</head>
<body>
  <div id="map"></div>
  <script type="module">
    // MapLibre GL JS v6 is ESM only: no UMD bundle, no `maplibregl` global.
    import * as maplibregl from 'https://cdn.jsdelivr.net/npm/maplibre-gl@6.0.0/dist/maplibre-gl.mjs';
    import { MaptoolkitLogoControl } from 'https://cdn.jsdelivr.net/npm/@maptoolkit/maplibre-gl-logo/+esm';

    // Required for Arabic/Hebrew labels - MapLibre has no right-to-left support built in
    maplibregl.setRTLTextPlugin('https://cdn.jsdelivr.net/npm/@mapbox/mapbox-gl-rtl-text@0.4.0/dist/mapbox-gl-rtl-text.js', false);

    const map = new maplibregl.Map({
      container: 'map',
      style: 'https://styles.maptoolkit.org/summer.json',
      center: [16.37, 48.21], zoom: 12,   // [lng, lat]
      // Required. MapLibre defaults to { compact: true }, which collapses the
      // © line into a ⓘ button on the first drag, at any viewport width.
      attributionControl: { compact: false },
    });
    map.addControl(new MaptoolkitLogoControl());   // logo, bottom-left
    // © Maptoolkit © Openstreetmap is now permanently visible via the
    // AttributionControl, read from the style's TileJSON. Do not hand-write it.
  </script>
</body>
</html>
```

NPM: `npm i maplibre-gl @maptoolkit/maplibre-gl-logo`, then `import maplibregl from 'maplibre-gl'` and `import { MaptoolkitLogoControl } from '@maptoolkit/maplibre-gl-logo'`. `MaptoolkitLogoControl` accepts `{ position }` (`'bottom-left'` default, also `top-left`/`top-right`/`bottom-right`/`top-center`/`bottom-center`).

### Leaflet (via `@maplibre/maplibre-gl-leaflet`)

Leaflet has no native vector support; the plugin draws a MapLibre layer. Logo via `@maptoolkit/leaflet-logo` (added with `.addTo(map)`); copyright line via the layer's `attribution` option.

```html
<link href="https://cdn.jsdelivr.net/npm/leaflet@1.9.4/dist/leaflet.css" rel="stylesheet">
<link href="https://cdn.jsdelivr.net/npm/maplibre-gl@6.0.0/dist/maplibre-gl.css" rel="stylesheet">
<div id="map" style="position:absolute;inset:0"></div>
<script src="https://cdn.jsdelivr.net/npm/leaflet@1.9.4/dist/leaflet.js"></script>
<script type="module">
  import * as maplibregl from 'https://cdn.jsdelivr.net/npm/maplibre-gl@6.0.0/dist/maplibre-gl.mjs';
  import { MaptoolkitLogoControl } from 'https://cdn.jsdelivr.net/npm/@maptoolkit/leaflet-logo/+esm';

  // Required for Arabic/Hebrew labels - MapLibre has no right-to-left support built in
  maplibregl.setRTLTextPlugin('https://cdn.jsdelivr.net/npm/@mapbox/mapbox-gl-rtl-text@0.4.0/dist/mapbox-gl-rtl-text.js', false);

  // maplibre-gl-leaflet is UMD with no ESM build and reads the global when it
  // loads, so assign it first and pull the plugin in dynamically.
  window.maplibregl = maplibregl;
  await import('https://cdn.jsdelivr.net/npm/@maplibre/maplibre-gl-leaflet@0.0.22/leaflet-maplibre-gl.js');

  const map = L.map('map').setView([48.21, 16.37], 12);   // [lat, lng]
  L.maplibreGL({
    style: 'https://styles.maptoolkit.org/summer.json',
    attribution:
      "<a href='https://www.maptoolkit.com/copyright/' target='_blank' rel='noopener'>© Maptoolkit</a> " +
      "<a href='https://www.openstreetmap.org/copyright' target='_blank' rel='noopener'>© Openstreetmap</a>",
  }).addTo(map);
  new MaptoolkitLogoControl().addTo(map);   // logo, bottom-left
</script>
```

### OpenLayers (via `ol-mapbox-style`)

`ol-mapbox-style` applies the style and may surface the © line via OpenLayers' own attribution control. Add the attribution overlay for the logo; drop its `.mtk-copy` span if the © line already shows, otherwise keep it.

```html
<link href="https://cdn.jsdelivr.net/npm/ol@10/ol.css" rel="stylesheet">
<div id="map" style="position:absolute;inset:0"></div>
<!-- paste the "Attribution overlay" snippet here, inside #map -->
<script type="module">
  import Map from 'https://cdn.jsdelivr.net/npm/ol@10/Map.js';
  import View from 'https://cdn.jsdelivr.net/npm/ol@10/View.js';
  import { fromLonLat } from 'https://cdn.jsdelivr.net/npm/ol@10/proj.js';
  import { apply } from 'https://cdn.jsdelivr.net/npm/ol-mapbox-style@12/+esm';
  const map = new Map({ target: 'map', view: new View({ center: fromLonLat([16.37, 48.21]), zoom: 12 }) });
  apply(map, 'https://styles.maptoolkit.org/summer.json');
</script>
```

### Deck.gl (via `MVTLayer`)

Deck.gl reads raw MVT and adds no attribution - the overlay is required. The `mtk` vector source is exposed as a TileJSON URL, which `MVTLayer` accepts directly.

```html
<div id="map" style="position:absolute;inset:0"></div>
<!-- paste the "Attribution overlay" snippet here, inside #map -->
<script type="module">
  import { Deck } from 'https://cdn.jsdelivr.net/npm/@deck.gl/core@9/+esm';
  import { MVTLayer } from 'https://cdn.jsdelivr.net/npm/@deck.gl/geo-layers@9/+esm';
  const style = await fetch('https://styles.maptoolkit.org/summer.json').then(r => r.json());
  new Deck({
    initialViewState: { longitude: 16.37, latitude: 48.21, zoom: 12 },
    controller: true,
    layers: [ new MVTLayer({
      id: 'mtk',
      data: style.sources.mtk.url,   // TileJSON URL of the basemap vector source
      stroked: true, filled: true,
      getLineColor: [80,80,80], getFillColor: [220,220,220], lineWidthMinPixels: 0.5,
    }) ],
  });
</script>
```

For a fully-styled flat basemap prefer MapLibre GL JS (it also has a 3D globe projection).

### CesiumJS (via `cesium-mvt-imagery-provider`)

Cesium reads raw MVT and adds no attribution - the overlay is required. Resolve the `.mvt` template from the `mtk` TileJSON.

```html
<div id="cesiumContainer" style="position:absolute;inset:0"></div>
<!-- paste the "Attribution overlay" snippet here, inside #cesiumContainer -->
<script type="module">
  import { Viewer } from 'https://cdn.jsdelivr.net/npm/cesium@1/+esm';
  import { MVTImageryProvider } from 'https://cdn.jsdelivr.net/npm/cesium-mvt-imagery-provider/+esm';
  const style = await fetch('https://styles.maptoolkit.org/summer.json').then(r => r.json());
  const tj = await fetch(style.sources.mtk.url).then(r => r.json());   // TileJSON
  const viewer = new Viewer('cesiumContainer');
  viewer.imageryLayers.addImageryProvider(new MVTImageryProvider({
    urlTemplate: tj.tiles[0],          // https://tiles.maptoolkit.org/.../{z}/{x}/{y}.mvt
    maximumLevel: tj.maxzoom,          // 15
    style: () => ({ fillStyle: '#dcdcdc', strokeStyle: '#808080', lineWidth: 0.5 }),
  }));
</script>
```

### kepler.gl

kepler.gl is a React/Redux app (no single-file drop-in) and renders its base map with MapLibre. Register Maptoolkit as a **custom map style**; the `© Maptoolkit © Openstreetmap` line then loads from the TileJSON, but it runs with MapLibre's collapsing default and cannot be configured from outside kepler (see the caveat). kepler also does not add the Maptoolkit logo, so render the attribution overlay over kepler's map container for both pieces.

```js
// Custom map style object for kepler's addCustomMapStyle action / mapStyle config:
const maptoolkitStyle = {
  id: 'maptoolkit-summer',
  label: 'Maptoolkit Summer',
  url: 'https://styles.maptoolkit.org/summer.json',
  icon: 'https://www.maptoolkit.org/assets/preview.webp',
  layerGroups: [],
};
// import { addCustomMapStyle, inputMapStyle } from '@kepler.gl/actions';
// dispatch(inputMapStyle(maptoolkitStyle));
// dispatch(addCustomMapStyle());
```

Then mount the attribution overlay (see the Attribution section) inside the container that wraps `<KeplerGl/>` so the 24 px logo stays visible. Keep the `.mtk-copy` span too - kepler's own © line disappears on the first drag, so the overlay is the one that has to carry it. Hide kepler's attribution element with CSS if the duplicate line bothers you.

## Native & mobile SDKs

All native SDKs load the same style URL. Attribution on native: the `© Maptoolkit © Openstreetmap` line is shown by the SDK's built-in attribution (info) button, which reads it from the `mtk` TileJSON. You must additionally show the **Maptoolkit logo** (>= 24 pt/dp) - there is no logo package for native, so place the downloadable asset (<https://www.maptoolkit.org/assets/maptoolkit-attribution.png>) as a fixed overlay on the map view.

### MapLibre Native iOS

Swift Package Manager: `https://github.com/maplibre/maplibre-gl-native-distribution` (or the `MapLibre` CocoaPod).

```swift
import MapLibre

let styleURL = URL(string: "https://styles.maptoolkit.org/summer.json")
let mapView = MLNMapView(frame: view.bounds, styleURL: styleURL)
mapView.setCenter(CLLocationCoordinate2D(latitude: 48.21, longitude: 16.37), zoomLevel: 12, animated: false)
view.addSubview(mapView)
// Add the Maptoolkit logo image (>= 24 pt) as a subview pinned bottom-left.
```

### MapLibre Native Android

`build.gradle`:

```groovy
implementation 'org.maplibre.gl:android-sdk:13.0.0'
```

```kotlin
MapLibre.getInstance(this)
mapView.getMapAsync { map ->
  map.setStyle(Style.Builder().fromUri("https://styles.maptoolkit.org/summer.json"))
  map.cameraPosition = CameraPosition.Builder()
    .target(LatLng(48.21, 16.37)).zoom(12.0).build()
}
// Add the Maptoolkit logo drawable (>= 24 dp) pinned bottom-left.
```

### Flutter

**`maplibre_gl` (recommended)** - wraps MapLibre Native, full vector rendering:

```yaml
dependencies:
  maplibre_gl: ^0.20.0
```

```dart
MaplibreMap(
  styleString: 'https://styles.maptoolkit.org/summer.json',
  initialCameraPosition: const CameraPosition(target: LatLng(48.21, 16.37), zoom: 12),
);
// Overlay the Maptoolkit logo (>= 24 dp), e.g. in a Stack, pinned bottom-left.
```

**`flutter_map` + `vector_map_tiles`** - if you already use `flutter_map`:

```dart
final style = await StyleReader(uri: 'https://styles.maptoolkit.org/summer.json').read();

FlutterMap(
  options: const MapOptions(initialCenter: LatLng(48.21, 16.37), initialZoom: 12),
  children: [
    VectorTileLayer(theme: style.theme, sprites: style.sprites, tileProviders: style.providers),
  ],
);
```

### React Native

```bash
npm install @maplibre/maplibre-react-native
```

```jsx
import { MapView, Camera } from '@maplibre/maplibre-react-native';

export default function Map() {
  return (
    <MapView style={{ flex: 1 }} mapStyle="https://styles.maptoolkit.org/summer.json">
      <Camera defaultSettings={{ centerCoordinate: [16.37, 48.21], zoomLevel: 12 }} />
      {/* Overlay the Maptoolkit logo (>= 24 dp) pinned bottom-left. */}
    </MapView>
  );
}
```

Coordinates are `[lng, lat]`, same as MapLibre GL JS.

## Migration guides

The community service is a drop-in basemap source for projects coming off paid providers. The pattern is always the same: swap the SDK, drop the access token, point the map at the Maptoolkit style URL - then add the attribution as shown above.

### From Mapbox GL JS -> MapLibre GL JS

MapLibre GL JS is a fork of Mapbox GL JS v1 - the API is almost identical. Markers, popups, sources, layers, expressions and events keep their names and signatures.

```js
// Before
mapboxgl.accessToken = 'pk.your-mapbox-token';
const map = new mapboxgl.Map({ container: 'map', style: 'mapbox://styles/mapbox/streets-v12', center: [13.405, 52.52], zoom: 11 });

// After
const map = new maplibregl.Map({ container: 'map', style: 'https://styles.maptoolkit.org/summer.json', center: [13.405, 52.52], zoom: 11 });
```

Checklist: delete `mapboxgl.accessToken`; rename `mapboxgl` -> `maplibregl`; replace any `mapbox://` style/sprite/glyph URLs; rebuild Mapbox v2+ only features with MapLibre equivalents; add the Maptoolkit logo control.

### From Google Maps JavaScript API -> MapLibre GL JS

```js
// Before (Google Maps)
const map = new google.maps.Map(document.getElementById('map'), { center: { lat: 52.52, lng: 13.405 }, zoom: 11 });

// After (MapLibre + Maptoolkit)
const map = new maplibregl.Map({ container: 'map', style: 'https://styles.maptoolkit.org/summer.json', center: [13.405, 52.52], zoom: 11 });
```

Watch out for: **coordinate order** (Google `{lat,lng}` vs MapLibre `[lng,lat]`); replace `new google.maps.Marker` with `new maplibregl.Marker`, `InfoWindow` with `Popup`, `map.addListener('click', …)` with `map.on('click', …)`; remove the Google API key and billing; replace Google controls with `NavigationControl` / `ScaleControl`.

### From the Mapbox Mobile SDK -> MapLibre Native

MapLibre Native is a fork of the last open-source Mapbox Maps SDK (iOS v6.x, Android v9.x). Most apps are a prefix swap.

- **iOS** - `Mapbox-iOS-SDK` -> `MapLibre`; class prefix `MGL` -> `MLN`; drop `MGLAccountManager.accessToken`.
- **Android** - `com.mapbox.mapboxsdk:mapbox-android-sdk` -> `org.maplibre.gl:android-sdk`; package prefix `com.mapbox.mapboxsdk` -> `org.maplibre.android`; replace `Mapbox.getInstance(context, token)` with `MapLibre.getInstance(context)`.

The newer proprietary Mapbox SDKs (iOS v10+, Android v10+) use a different API and require more than a prefix swap.

## Maptoolkit.org vs. other free vector basemaps

Maptoolkit.org is one of several free, OSM-based vector basemap projects for MapLibre. Detail pages: [OpenMapTiles](https://maptoolkit.org/compare/openmaptiles) · [Protomaps](https://maptoolkit.org/compare/protomaps) · [OpenFreeMap](https://maptoolkit.org/compare/openfreemap) · [VersaTiles](https://maptoolkit.org/compare/versatiles) · full comparison: <https://maptoolkit.org/compare>

| Dimension | Maptoolkit.org | OpenMapTiles | Protomaps | OpenFreeMap | VersaTiles |
|---|---|---|---|---|---|
| Available as | Free tile server | Do-it-yourself toolchain | Limited tile server, data download | Free tile server, data download | Free tile server, data download |
| Cost | Free | Free | Free tile server for non-commercial use, free downloads | Free | Free |
| Monthly request limits | unlimited | - | 1M tile requests | unlimited | unlimited |
| Attribution | © Maptoolkit © Openstreetmap + logo | © OpenMapTiles © OpenStreetMap contributors | © Protomaps © OpenStreetMap | OpenFreeMap © OpenMapTiles – Data from OpenStreetMap | © OpenStreetMap contributors |
| API key / sign-up | None | - | API key | None | None |
| Commercial use | Yes (&lt; EUR 1M/yr) | Yes | Yes (downloads only) | Yes | Yes |
| OSM updates | Weekly | - | Daily (API) | Weekly | Several times per year |
| Max data zoom | 15 | 14 | 15 | 14 | 14 |
| Tile schema | Maptoolkit | OpenMapTiles | Protomaps | OpenMapTiles | Shortbread |
| Standard styles | Summer, Light, Hiking, Winter, Dark, Street, Cycling (7) | OpenMapTiles, Basic, Bright, Positron, Dark Matter, Fiord Color, Toner (7) | Light, Dark, White, Grayscale, Black (5) | Liberty, Positron, Bright, Dark, Fiord (5) | Colorful, Eclipse, Graybeard, Shadow, Neutrino (5) |
| Style editor | MapMaker | - | - | - | tiles.versatiles.org |
| Hillshading / contour lines | Yes | - | - | - | Just hillshade, download only |
| Water depths | Yes | - | - | - | Download only |
| 3D terrain | Yes | - | - | - | Download only |
| Provider | Maptoolkit.com, Austria & Germany | Maptiler.com, Switzerland | Brandon Liu (individual), USA | Zsolt Ero (individual), Hungary | Michael Kreil (individual), Germany |
| Privacy | [Privacy Policy](https://www.maptoolkit.org/privacy) | - | [Privacy info](https://docs.protomaps.com/guide/security-privacy) | [Privacy Policy](https://openfreemap.org/privacy/) | - |

## Community License - what you can and can't do

Free of charge under these conditions:

**Who may use it**
- Non-commercial projects (personal sites, hobby, open-source, academic, educational).
- Small commercial projects: **under EUR 1M** annual consolidated revenue **and** fewer than **10 FTE** employees.
- Above either threshold -> Enterprise License (<https://www.maptoolkit.com>).

**How it may be used**
- **Attribution is mandatory** (see above).
- **No** backend-only processing, bulk extraction, offline tile generation or mirroring.
- **No** reselling, sublicensing, repackaging, or hosting as part of another SaaS.
- **No** print use - use [Printmaps.net](https://www.printmaps.net/) instead.
- **No** Adult Content, Gambling/Betting, Get-Rich-Quick, Predatory Lending, Hate Speech / Extremism.

**What you get**
- Unlimited requests (subject to fair-use and burst protection).
- Production-grade vector tiles cached at 350+ Cloudflare edge POPs.
- Hosted in the EU; GDPR-compliant; cookie-free; no API keys; no `Referer`/`User-Agent` logs.
- Best-effort service: **no** SLA, uptime guarantee or support obligation.

Full text: <https://www.maptoolkit.org/tos> · Privacy: <https://www.maptoolkit.org/privacy>

## Fair use & rate limits

To keep the shared infrastructure stable, adaptive rate limiting applies. Tiles/s are counted at Maptoolkit's **origin servers only** - tiles served from Cloudflare's edge cache (typically **90%+** of traffic) **don't count**. A normal interactive map user rarely generates more than a handful of countable requests per second.

| Tier                                    | Per website - Sustained | Per website - Burst | Per user (per IP)       |
|-----------------------------------------|-------------------------|---------------------|-------------------------|
| Unregistered (default)                  | 120 tiles/s             | 200 tiles/s         | 40 tiles/s fair-use cap |
| Registered domain or app (coming soon)  | 600 tiles/s             | 1,000 tiles/s       | -                       |

Registration (a one-minute form - no credit card, no key to manage) raises a website's ceiling 5×. Native apps can register for a partner token instead. Registration is **coming soon** and is not required to use the service. Bulk downloading, scraping and similar automated workloads are not permitted.

## Data privacy summary

- No accounts, no API keys, no registration.
- No tracking cookies, no fingerprinting, no advertising IDs (no consent banner needed under ePrivacy).
- No user profiles, no cross-site identifiers, no data sales, no AI training on request data.
- Anonymised logs only: truncated IP (last octet zeroed, never persisted), timestamp, path, HTTP status, response size. `Referer` and `User-Agent` are **not** logged. Retention: **max. 15 days**, then permanently deleted.
- Origin in the EU; edge delivery + DDoS protection by Cloudflare (processor). Terrain tiles via `tiles.mapterhorn.com`, same model.
- When you embed the service, **you are the controller** for your end users' personal data (GDPR Art. 4(7)); Toursprung GmbH is an independent controller for operational logging only.

## Gotchas

- **Vector only.** No raster XYZ endpoint, no static-maps API. Libraries without vector support (Leaflet, OpenLayers) use a plugin to render the MapLibre style.
- **Coordinate order is `[lng, lat]`** in MapLibre/Deck.gl/CesiumJS - the opposite of Google Maps' `{lat, lng}`. Leaflet uses `[lat, lng]`.
- **The minimum client is GL JS 5.6.0, not v6.** The `color-relief` elevation shading in `summer`, `hiking`, `winter`, `cycling` and `dark` needs GL JS 5.6.0 (Native Android 13.0.0, iOS 6.24.0); `street` and `light` have no such requirement and work from 4.2.0. An older client silently ignores the unsupported layer type rather than throwing, so the symptom is missing shading with no console error - check the SDK version before debugging the tile source. v6 is still the recommended version to start from.
- **MapLibre GL JS v6 is ESM only.** There is no UMD bundle and no `maplibregl` global. Load it inside a `<script type="module">` with `import * as maplibregl from 'https://cdn.jsdelivr.net/npm/maplibre-gl@6.0.0/dist/maplibre-gl.mjs'`. A `<script src=".../maplibre-gl.js">` tag does not work any more - that file no longer exists in v6. UMD plugins that read the global (for example `maplibre-gl-leaflet`) need `window.maplibregl = maplibregl` assigned *before* they load.
- **Right-to-left labels need a plugin.** MapLibre GL JS ships neither the bidi algorithm nor Arabic letter joining, so Arabic and Hebrew labels render with unconnected letters in reverse order. Call `maplibregl.setRTLTextPlugin('https://cdn.jsdelivr.net/npm/@mapbox/mapbox-gl-rtl-text@0.4.0/dist/mapbox-gl-rtl-text.js', false)` once, before creating the map. It is a silent failure - nothing throws, the labels are just wrong - so add it to every browser map rather than waiting for a bug report.
- **Backend use is forbidden.** Tiles must be requested by the end-user's browser/device, not pre-fetched, mirrored, or proxied through your server.
- **`.org`, not `.net`.** The community service is `styles/tiles/fonts.maptoolkit.org`. The `*.maptoolkit.net` domains are the commercial product and require an API key - do not mix them.
- **Source key is `mtk`**, not `maptoolkit`. Read the basemap vector source from `style.sources.mtk` (TileJSON `url`, maxzoom 15).
- **Attribution is enforced.** Logo (>= 24 px / 24 pt/dp) + the `© Maptoolkit © Openstreetmap` line with two clickable links, visible at all times, never collapsed or obscured.
- **Terrain comes from a different origin.** Hillshading / 3D uses `https://tiles.mapterhorn.com/{z}/{x}/{y}.webp`; `preconnect` to it if you enable terrain.
- **Best-effort SLA.** Don't build life-safety, billing-critical or contractually-bound services on the community tier - that's what the Enterprise License is for.

## Official documentation & links

- [Landing page](https://www.maptoolkit.org/) · [Community Docs](https://docs.maptoolkit.org/) · [Quick Start](https://docs.maptoolkit.org/quick-start/)
- [Vector Tiles & styles](https://docs.maptoolkit.org/vector-tiles/) · [SDKs & Libraries](https://docs.maptoolkit.org/platform-libraries/)
- [MapLibre GL JS](https://docs.maptoolkit.org/platform-libraries/maplibre/) · [Examples gallery](https://docs.maptoolkit.org/platform-libraries/maplibre/examples/)
- [Leaflet](https://docs.maptoolkit.org/platform-libraries/leaflet/) · [OpenLayers](https://docs.maptoolkit.org/platform-libraries/openlayers/) · [Deck.gl](https://docs.maptoolkit.org/platform-libraries/deckgl/) · [CesiumJS](https://docs.maptoolkit.org/platform-libraries/cesiumjs/)
- [MapLibre Native iOS](https://docs.maptoolkit.org/platform-libraries/maplibre-native-ios/) · [Android](https://docs.maptoolkit.org/platform-libraries/maplibre-native-android/) · [Flutter](https://docs.maptoolkit.org/platform-libraries/flutter/) · [React Native](https://docs.maptoolkit.org/platform-libraries/react-native/)
- [Migrate from Mapbox GL JS](https://docs.maptoolkit.org/migration-guides/migrate-from-mapbox-gl-js/) · [from Google Maps](https://docs.maptoolkit.org/migration-guides/migrate-from-google-maps/) · [from the Mapbox Mobile SDK](https://docs.maptoolkit.org/migration-guides/migrate-from-mapbox-sdk/)
- [Data Privacy details](https://docs.maptoolkit.org/miscellaneous/data-privacy/)
- [Logo package - MapLibre](https://www.npmjs.com/package/@maptoolkit/maplibre-gl-logo) · [Logo package - Leaflet](https://www.npmjs.com/package/@maptoolkit/leaflet-logo)
- [Terms / Community License](https://www.maptoolkit.org/tos) · [Privacy](https://www.maptoolkit.org/privacy) · [Status](https://www.maptoolkit.org/status)
- [Support & Discussions (GitHub)](https://github.com/maptoolkit/maptoolkit.org/discussions) · [Enterprise (paid) - full API suite, SLA, custom data](https://www.maptoolkit.com)