POI categories

getPOICategories() returns every POI category the Search API knows, with its names and synonyms in a language. Use it to build a category picker, or to find categories by name or synonym. A category’s code, a POICategory, works in:

• Search filtering, with discoverPlaces({ filters: { poiCategories } }).
• The map’s own POI icons, with the POIsModule filters.categories setting, which takes generic parent codes only (Filtering the map’s built-in POI icons).

The Node.js POI categories example finds categories by keyword, best match first, and feeds their codes to discoverPlaces.

Basic usage

1
import { getPOICategories } from '@tomtom-org/maps-sdk/services';
2

3
const { poiCategories: categories } = await getPOICategories();
4

5
categories.forEach((category) => {
6
    console.log(category.name);               // e.g. "Sports Center"
7
    console.log(category.code);               // e.g. "SPORTS_CENTER"
8
    console.log(category.synonyms);           // e.g. ["Sports Centre"]
9
    console.log(category.childCategoryCodes); // e.g. ["FITNESS_CLUB_AND_CENTER", "HORSE_RIDING", ...]
10
});

Getting codes directly: getPOICategoryCodes

getPOICategoryCodes takes the same parameters and returns only the codes:

1
import { discoverPlaces, getPOICategoryCodes } from '@tomtom-org/maps-sdk/services';
2

3
const all = await getPOICategoryCodes();
4

5
// Codes matching a keyword, best match first, e.g. ['RESTAURANT', 'RESTAURANT_AREA']
6
const restaurantCodes = await getPOICategoryCodes({ filters: ['restaurant'] });
7

8
const results = await discoverPlaces({
9
    filters: { poiCategories: restaurantCodes },
10
    geoBias: { position: [4.9041, 52.3676] },
11
});

Fetching in a specific language

language localizes the names and synonyms, and defaults to the global language:

1
const { poiCategories: categories } = await getPOICategories({ language: 'fr-FR' });
2
console.log(categories[0].name); // e.g. "Centre sportif"

Filtering categories

filters finds categories by keyword. It matches client-side against the cached list, so it sends no request after the first. Each filter ranks the categories it matches, strongest first:

1. A category code, such as 'CAFE', matches that category only.
2. Any other filter ranks an exact name or synonym first, then a name or synonym that starts with the filter ('parking' finds 'Parking Garage'), then one with it as a later word, and last one containing it as a substring.

• A filter keeps only matches close to its best one, so 'bar' finds 'Bar' but not 'Nail Salon' through its synonym 'Nail Bar'.
• Matching ignores case, accents and punctuation. A substring match ignores spaces too. 'cafe' finds 'Café', and 'bookstore' finds 'Book Shop' through its synonym 'Book Store'. A blank filter matches nothing.
• Several filters merge round-robin, so each filter’s best match comes first, with one entry per code. A category ranked below its matched parent is left out, because the parent already covers it.

1
const { poiCategories: gymCategories } = await getPOICategories({ filters: ['gym'] });
2

3
// Each filter's best match first, one entry per code
4
const { poiCategories: combined } = await getPOICategories({ filters: ['gym', 'parking'] });
5

6
const { poiCategories: restaurants } = await getPOICategories({ language: 'en-GB', filters: ['restaurant'] });

Using categories in search

Pass code values to discoverPlaces(), such as the one picked from a dropdown:

1
import { discoverPlaces, getPOICategories } from '@tomtom-org/maps-sdk/services';
2

3
const { poiCategories: allCategories } = await getPOICategories();
4
const options = allCategories.map((category) => ({ label: category.name, value: category.code }));
5

6
const results = await discoverPlaces({
7
    filters: { poiCategories: ['SPORTS_CENTER'] },
8
    geoBias: { position: [4.9041, 52.3676] },
9
    limit: 20,
10
});

When the category comes as a word rather than a choice from a list, skip the lookup and pass it as filters.poiCategoryQuery, which resolves it with resolvePOICategories:

1
const gyms = await discoverPlaces({ filters: { poiCategoryQuery: 'gym' }, geoBias: { position: [4.9041, 52.3676] } });

Resolving words for a search: resolvePOICategories

resolvePOICategories turns words, or codes, into the poiCategories of one search, and reports the words that match nothing. Call it before searching to handle those words yourself. You can search with the rest, ask the user or fall back to a free-text query.

1
import { discoverPlaces, resolvePOICategories } from '@tomtom-org/maps-sdk/services';
2

3
const { poiCategories, unmatched } = await resolvePOICategories({ filters: ['café', 'PHARMACY', 'xyzzy'] });
4
// unmatched: ['xyzzy']
5

6
if (poiCategories.length) {
7
    const places = await discoverPlaces({ filters: { poiCategories }, geoBias: { position: [4.9041, 52.3676] } });
8
}

• Each filter matches as in Filtering categories, so a code stays itself.
• It keeps each filter’s best three codes, merged round-robin and capped at the 10 a search accepts.
• filters.poiCategoryQuery runs this lookup, so both resolve a word the same way.
• Codes alone skip the catalogue request and come back as given, never folded into a parent, with duplicates dropped.
• resolvePOICategories builds one search, while getPOICategoryCodes lists every close match, for a picker or the map’s POI icons.

Filtering the map’s built-in POI icons

To choose which of the map’s own POI icons show, set the POIsModule filters.categories setting to generic parent codes or POICategoryGroup values such as 'FOOD_DRINKS_GROUP'. It doesn’t support specific child codes such as 'ITALIAN_RESTAURANT', so use the parent 'RESTAURANT' or a group. The POIs module guide covers the setting and its groups.

1
import { POIsModule, TomTomMap } from '@tomtom-org/maps-sdk/map';
2
import { getPOICategoryCodes } from '@tomtom-org/maps-sdk/services';
3

4
const map = new TomTomMap({ mapLibre: { container: 'map' } });
5
const poisModule = await POIsModule.get(map);
6

7
const codes = await getPOICategoryCodes({ filters: ['restaurant', 'sports center'] });
8
poisModule.updateConfig({ filters: { categories: { show: 'only', values: codes } } });

Exploring sub-categories

childCategoryCodes lists a category’s sub-categories, for drill-down navigation:

1
const { poiCategories: categories } = await getPOICategories();
2

3
const restaurant = categories.find((category) => category.code === 'RESTAURANT');
4
console.log(restaurant?.childCategoryCodes); // e.g. ['ITALIAN_RESTAURANT', 'FRENCH_RESTAURANT', ...]

Note that a search by a parent code returns places in these sub-categories too.

Cache management

• The first call in a language fetches the list. Every later call in that language reads the cache, filtered or not, including resolvePOICategories and filters.poiCategoryQuery.
• The cache is in memory for the lifetime of the page or process. There is nothing to clear.

1
const { poiCategories: english } = await getPOICategories({ language: 'en-GB' });
2
const { poiCategories: french } = await getPOICategories({ language: 'fr-FR' }); // a second request

Parameter reference

On top of the options every service call takes:

Response reference

Each entry of poiCategories:

resolvePOICategories returns { poiCategories, unmatched } instead. It holds the codes for one search, best first, and the filters that matched nothing, as given.

Related guides

• Discover places — Searching by category code or by category in words
• POIs module — The map’s own POI icons, filtered by parent codes or groups
• Search suggestions — A category the user is typing, as a category suggestion