No CMS or framework detected, hosted on Cloudflare. Domain registered in 2026.
maptoolkit.org is hosted on Cloudflare. It measures traffic with Plausible Analytics.
| Technology | Version | First seen |
|---|---|---|
| Web Servers, Languages & Backend Frameworks1 | ||
| – | 7 Nov 2026 | |
| CDN & Hosting1 | ||
| – | 7 Nov 2026 | |
| Analytics & Tag Management1 | ||
| – | 7 Nov 2026 | |
| Maps, Geocoding & Geolocation1 | ||
| – | 7 Nov 2026 | |
| Reviews, Ratings & Social Proof1 | ||
| – | 7 Nov 2026 | |
Registration from the registry's RDAP record, the certificate the site serves, and its rank in public traffic lists.
The crew hasn’t read this site’s colors yet. We read a palette when we capture a site’s screenshot, busiest sites first. Meanwhile, browse palettes from other sites.
Counted from every stack change we've recorded: of the sites we watched running one of this site's tools, how many went on to add another. A pattern across sites, not a forecast for this one.
mx01.easyname.eumx02.easyname.euelle.ns.cloudflare.comowen.ns.cloudflare.comsite24x7-signals-domain-verification=33995607254ab2ebb5e56e3a33a11294v=spf1 include:spf.easyname.com -allgoogle-site-verification=hSBb963ImGSL2Vj1JuEw04f4FwtiZMFtyeQLO10H9kYgoogle-site-verification=B5G-BIODMFK-jG8mKh8-848ahXDLSYW231rxg4yOzL0User-agent: * Disallow: Sitemap: https://www.maptoolkit.org/sitemap.xml
# 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. */}
</Ma