Migrating from Maps SDK for Web V6

Maps SDK for Web V6 was deprecated on February 1, 2025, and its CDN endpoints were withdrawn on February 1, 2026. They answer 404 unless your contract runs past that date, and then only until it ends. V6 receives no further updates, security patches or bug fixes. The Maps SDK for JavaScript replaces it.

Migration carries no additional cost. Your API key, contract and per-call pricing stay the same (Pricing and commercial impact).

Why migrate

Feature comparison

Map display

Services

Developer experience

Plugins

Estimating migration effort

Use the table below to estimate the effort from the V6 features you use.

For most integrations using map display, routing and traffic, expect 2–4 developer-days of migration work, with the 110+ runnable examples to check each feature against.

V6 API to new SDK

Find each V6 call you use and its replacement. Services come from @tomtom-org/maps-sdk/services and map classes from @tomtom-org/maps-sdk/map. None of them takes a key, because the global configuration holds it.

Map

Services

Responses are GeoJSON as returned, so there is no toGeoJson(). Positions are [longitude, latitude] arrays throughout.

Step-by-step migration

Migrate incrementally, following only the sections your integration needs. The SDK works at two levels, which you can mix:

• At the high level, map modules draw what services return, with no layer management of your own.
• At the low level, map.mapLibreMap is the full MapLibre API. It is the most direct path for V6 code that called the map's low-level methods (Using TomTom map with MapLibre directly). As you go, move each feature up to a module to get what the SDK adds.

Install the new SDK

Remove the legacy packages and CDN references, then install the new SDK:

# Remove legacy packages
npm uninstall @tomtom-international/web-sdk-maps @tomtom-international/web-sdk-services

# Install new SDK (peer dependencies installed automatically)
npm install @tomtom-org/maps-sdk

Also remove any V6 CDN <script> and <link> tags from your HTML. Your existing API key works with the new SDK.

Set up centralized configuration

The new SDK uses a singleton configuration pattern. Set your API key once at startup, and it applies to all maps and service calls.

Before (V6):

// API key passed to every call individually
var map = tt.map({ key: 'YOUR_API_KEY', container: 'map' });
tt.services.fuzzySearch({ key: 'YOUR_API_KEY', query: 'pizza' });

After:

import { TomTomConfig } from '@tomtom-org/maps-sdk/core';

// Set once at app startup — used by all maps and service calls
TomTomConfig.instance.put({
    apiKey: 'YOUR_API_KEY',
    language: 'en-GB',
});

You can still override the key per call or per map.

Migrate map initialization

Before (V6):

var map = tt.map({
    key: 'YOUR_API_KEY',
    container: 'map',
    center: [4.8156, 52.4414],
    zoom: 8,
});

After:

import { TomTomMap } from '@tomtom-org/maps-sdk/map';

const map = new TomTomMap({
    mapLibre: {
        container: 'map',
        center: [4.8156, 52.4414],
        zoom: 8,
    },
});

Map options (center, zoom, bearing, pitch, and all other MapLibre options) pass through unchanged under the mapLibre key.

Available styles:

V6's separate trafficFlow, trafficIncidents and poi styles have no names of their own. You load the traffic parts with include (see Migrate traffic layers), and show, hide and filter the style's own POIs with the POIs module.

const map = new TomTomMap({
    style: 'streetDark',
    mapLibre: { container: 'map' },
});

To switch style at runtime, call await map.setStyle('streetLight'). In V6, setStyle dropped every layer you had added. The SDK's modules keep their data and settings and redraw on the new style (Map styles).

Migrate routing

Before (V6):

tt.services.calculateRoute({
    key: 'YOUR_API_KEY',
    locations: '4.89,52.37:4.88,52.36',
}).then(function(routeData) {
    var geojson = routeData.toGeoJson();
    map.addLayer({ /* ... */ });
});

After:

import { calculateRoute } from '@tomtom-org/maps-sdk/services';
import { RoutingModule } from '@tomtom-org/maps-sdk/map';

const routes = await calculateRoute({
    locations: [
        [4.89, 52.37],   // [longitude, latitude]
        [4.88, 52.36],
    ],
    travelMode: 'car',
});

// Pass directly to RoutingModule — no .toGeoJson() or manual layer setup needed
const routingModule = await RoutingModule.create(map);
await routingModule.showRoutes(routes);

The response is standard GeoJSON, with no .toGeoJson() conversion step. RoutingModule handles the layers, default styling, waypoint icons and traffic-section colouring, so the route renders with a single call and looks production-ready by default. The module has configuration options for a different colour scheme, custom line widths or your own waypoint markers.

To manage the map layers yourself, closer to how V6 worked, pass the GeoJSON response directly to map.mapLibreMap.addSource / addLayer:

// Low-level approach — use the MapLibre instance directly
map.mapLibreMap.addSource('route', { type: 'geojson', data: routes });
map.mapLibreMap.addLayer({ id: 'route-line', type: 'line', source: 'route', paint: { 'line-color': '#0080ff', 'line-width': 4 } });

Layers added this way are dropped by setStyle and get no SDK events. To keep your own layer specs with both, give them to the Custom GeoJSON module instead.

Migrate search and geocoding

Search and geocoding responses are standard GeoJSON, so you can pass them directly to the map. PlacesModule renders search results on the map as styled, interactive markers with minimal setup. For a data-only integration, the GeoJSON features work equally well with any MapLibre data source.

Before (V6):

tt.services.fuzzySearch({
    key: 'YOUR_API_KEY',
    query: 'restaurant',
    center: { lat: 52.37, lng: 4.89 },
}).then(function(results) { /* ... */ });

After:

import { discoverPlaces } from '@tomtom-org/maps-sdk/services';

const results = await discoverPlaces({
    query: 'restaurant',
    geoBias: { position: [4.89, 52.37] }, // [longitude, latitude]
});
// results is a typed GeoJSON FeatureCollection — access via results.features

For reverse geocoding:

Before (V6):

tt.services.reverseGeocode({
    key: 'YOUR_API_KEY',
    position: { lat: 52.37, lng: 4.89 },
}).then(response => { /* ... */ });

After:

import { reverseGeocode } from '@tomtom-org/maps-sdk/services';

const place = await reverseGeocode({ position: [4.89, 52.37] });
const address = place.properties.address;

Migrate traffic layers

TrafficFlowModule and TrafficIncidentsModule connect live TomTom traffic data to the map with pre-styled, interactive layers. Incident markers are clickable and richly styled out of the box. You can filter them by magnitude, category or road type without writing any rendering logic, and customise the modules if you need a different look.

Before (V6):

var map = tt.map({
    key: 'YOUR_API_KEY',
    container: 'map',
    stylesVisibility: { trafficFlow: true, trafficIncidents: true },
});
// Toggle later:
map.showTrafficFlow();
map.hideTrafficFlow();

After:

import { TomTomMap, TrafficFlowModule, TrafficIncidentsModule } from '@tomtom-org/maps-sdk/map';

// Include traffic layers when initializing the map style
const map = new TomTomMap({
    style: { type: 'standard', id: 'streetLight', include: ['trafficFlow', 'trafficIncidents'] },
    mapLibre: { container: 'map' },
});

const trafficFlow = await TrafficFlowModule.get(map, { visible: true });
const trafficIncidents = await TrafficIncidentsModule.get(map, { visible: true });

// Toggle visibility
trafficFlow.setVisible(false);
trafficIncidents.setVisible(true);

// Typed filtering — show only major and moderate incidents
trafficIncidents.updateConfig({
    filters: { magnitudes: { show: 'only', values: ['major', 'moderate'] } },
});

Migrate custom styling

In V6, you restyled the map by editing a style in Map Styler and loading its JSON. The new SDK loads standard styles only. Instead, the Styling Foundations module changes a style at runtime, and the change survives style switches.

import { setKnob, StylingFoundationsModule, stylingFoundationsKnobCatalogue } from '@tomtom-org/maps-sdk/map';

const styling = await StylingFoundationsModule.get(map);
setKnob(styling, stylingFoundationsKnobCatalogue, 'labels.sizeFactor', 1.2); // every base-map label 20% bigger
setKnob(styling, stylingFoundationsKnobCatalogue, 'roads.widthFactor', 0.8);  // thinner roads, hierarchy kept
styling.setMapColors({ land: '#f3f5f7', water: '#accbe2', roadMajor: '#a1b8ce' });

The map theme plugin derives those colours for you from your brand colours, your site's CSS or an image. exportStyle saves the result as a style file.

Update CSS

Before (V6):

<link rel='stylesheet' href='https://api.tomtom.com/maps-sdk-for-web/cdn/6.x/.../maps.css'>

After:

The SDK applies the MapLibre CSS itself, from its own bundle. You only need this import to use the CSS of the MapLibre version you installed.

// In your JS/TS entry point
import 'maplibre-gl/dist/maplibre-gl.css';

Performance improvements

Bundle size

With modular ESM, you only ship the code you use. With tree-shaking enabled:

Rendering engine

• MapLibre GL JS is actively maintained with performance improvements in every release
• Vector tile rendering runs on WebGL 2, which the map requires. In a browser without it, new TomTomMap throws a TomTomMapError with the code WEBGL_UNSUPPORTED
• Style part lazy loading enables faster initial map display by loading layers on demand
• Layer group visibility animation support for smooth UX transitions

API response handling

• Native GeoJSON responses eliminate the serialisation/deserialisation overhead of V6's .toGeoJson() conversion
• Typed responses enable compile-time validation, reducing runtime errors

Future-proof with Orbis Maps

The new SDK is the first to support TomTom Orbis Maps natively. Orbis Maps is the next-generation map data platform that combines open data (OpenStreetMap) with TomTom's proprietary data.

After migrating, your application gets every Orbis Maps improvement automatically.

Pricing and commercial impact

• Your API key stays the same. No new key is required.
• Per-call pricing stays the same. Both SDKs call the same backend APIs, billed at the same rate whichever SDK made the call.
• Contract terms stay the same. Your existing agreement covers the new SDK, with no amendment.
• The free evaluation plan's daily requests cover prototyping and testing the migration.
• Tailored enterprise plans, QPS limits and support levels carry over.

Using TomTom map with MapLibre directly

TomTomMap exposes the underlying MapLibre GL JS instance as map.mapLibreMap. Through it, the full MapLibre API (addSource, addLayer, on, queryRenderedFeatures and everything else) works exactly as in a standalone MapLibre project.

This is the most direct migration path for V6 code that calls TomTom's tt.map methods directly. Replace tt.map(...) with new TomTomMap(...), swap the CSS import, and then migrate the rest of the codebase incrementally. Each time a feature is ready for a high-level module, replace its manual layer code. Everything else keeps working unchanged through map.mapLibreMap.

import { TomTomMap } from '@tomtom-org/maps-sdk/map';

const map = new TomTomMap({ mapLibre: { container: 'map' } });

map.mapLibreMap.on('load', () => {
    // Standard MapLibre API
    map.mapLibreMap.addSource('my-data', { type: 'geojson', data: myGeojson });
    map.mapLibreMap.addLayer({ id: 'my-layer', type: 'fill', source: 'my-data' });
});

Custom data visualisation, such as heatmaps, clustering, choropleth maps and deck.gl layers, works through map.mapLibreMap without any SDK-specific code. You can use the high-level modules and the raw MapLibre API on the same map instance at once. For GeoJSON layers, the Custom GeoJSON module takes the same layer specs and restores them after every style switch.

What's not yet available

The new SDK is in Public Preview (0.x versions). Until 1.0, a minor release can carry a breaking change, and Upgrading to 1.0 lists each one. Some V6 capabilities are not yet available as first-party SDK features:

• SearchBox plugin - No drop-in replacement yet. Build on getSearchSuggestions(), starting from the search playground.
• Minimap / DrawingTools plugins - Use MapLibre community plugins, listed in awesome-maplibre.
• Turn-by-turn navigation UI - In-car navigation UI components are not yet available.
• Long-distance EV routing, vehicle consumption models and live EV charging availability - Not offered. Search returns EV stations with their static connectors and charging points.
• Matrix routing, structured geocoding, cross-street lookup, static map images, traffic flow segment data and incident viewport - No SDK function yet, so call those TomTom APIs over HTTP. For structured geocoding, pass the full address to geocode.
• CDN-only deployment - The new SDK requires a bundler (Vite, Webpack, etc.).

For GeoJSON data that no first-party module covers, use the Custom GeoJSON module. For anything else, map.mapLibreMap is the full MapLibre GL JS API.

Further reading

• How the SDK works — Architecture overview and key concepts
• Project setup — Installation and API key configuration
• Map quickstart — Your first map in minutes
• Services quickstart — Search and routing
• Core quickstart — What glues map and services together
• Map modules — Traffic, routing, places, and more
• Map styles — Built-in themes and switching them
• Map styling — Restyle the map at runtime with knobs, brand colours and presets
• Terrain — Hillshade and 3D elevation
• Geopolitical views — One view for the map and every service call
• About MapLibre — What the SDK adds over raw MapLibre, and when to use map.mapLibreMap directly
• Traffic flow — Configuring live traffic flow layers
• Traffic incidents — Filtering and displaying incidents
• Routing guide — Route calculation parameters and options
• Search guide — Fuzzy, geometry and along-route search
• Search suggestions — Search-as-you-type over places, brands and categories
• Geocoding / Reverse geocoding
• Proxying your API calls — Keep the API key on your server
• Map theme, Map effects, Fly-over, Viewport places, Agent Toolkit — Plugins with no V6 counterpart
• AI coding with the SDK — The skill for your coding agent
• Upgrading to 1.0 — Breaking changes between 0.x releases
• API reference — Complete TypeDoc reference