# TomTom

> Put TomTom's maps to work: search for places and addresses anywhere in the world, turn written addresses into coordinates and coordinates back into addresses, find everything of a given kind around a point, plan routes for cars, trucks, bikes or on foot with live traffic and a departure or arrival time, work out everywhere reachable inside a time or distance budget, and read the crashes, jams, closures and road works happening around any place right now.

App · Travel & Places · 10 actions. Web page: https://docs.lodol.com/docs/integrations/tomtom

## Actions

### Calculate a reachable range

Everywhere you can get to from one place inside a time or distance budget: a drive-time area, sometimes called an isochrone. The answer to 'which customers are within 30 minutes of this depot', 'how far can this van get before its next stop', or 'draw the catchment area of this branch'. Returns the boundary as a list of coordinates plus the box that contains it, so it can be drawn on a map or tested against a list of addresses. The start takes an address or coordinates; the budget defaults to 30 minutes by car.

**Inputs**

- Starting from (`origin`, text, required): The place the range is measured from: an address, a place name, or 'latitude,longitude'.
- Within (minutes) (`time_budget_minutes`, number): How long the trip may take. Defaults to 30 minutes when neither budget is set. Use this or a distance budget, not both. From 1 to 166666.
- Within (km) (`distance_budget_km`, number): How far the trip may go, in kilometres. Use this or a time budget, not both. From 0.1 to 50000.
- Travelling by (`travel_mode`, text): What the trip is made in or on. One of: `car`, `truck`, `taxi`, `bus`, `van`, `motorcycle`, `bicycle`, `pedestrian` (On foot). Default: `car`.
- Optimise for (`route_type`, text): Which kind of route the range is measured along. One of: `fastest` (Fastest (shortest travel time)), `shortest` (Shortest (shortest distance)), `eco` (Eco (balances time against fuel or energy used)), `thrilling` (Thrilling (winding roads and fewer motorways)). Default: `fastest`.
- Leaving at (`depart_at`, date and time): Optional. Measure the range for this departure time, using the traffic expected then.
- Use live traffic (`use_traffic`, true/false): Take current and expected traffic into account. Default: `true`.
- Avoid (`avoid`, list): Optional. Road types to keep out of the range. One or more of: `tollRoads` (Toll roads), `motorways`, `ferries`, `unpavedRoads` (Unpaved roads), `carpools` (Carpool (HOV) lanes), `alreadyUsedRoads` (Roads already used on this route).
- Engine (`engine_type`, text): Optional. What the vehicle runs on, which changes how the range is worked out. One of: `combustion` (Petrol or diesel), `electric`.
- Boundary smoothing (`smoothing`, text): Optional. How much to smooth the outline. Stronger smoothing gives a tidier shape to draw on a map. One of: `none` (None (raw polygon)), `weak` (Light), `strong` (Strong (smoothest outline)).

**Outputs**

- `boundary` (list): The outline of the reachable area, as an ordered list of coordinates.
- `boundary_point_count` (number): How many points the outline has.
- `center_latitude` (number): Latitude of the point the range centres on.
- `center_longitude` (number): Longitude of the point the range centres on.
- `distance_budget_km` (number): The distance budget used, when it was a distance budget.
- `found` (true/false): Whether a range could be worked out.
- `max_latitude` (number): Northern edge of the box containing the range.
- `max_longitude` (number): Eastern edge of the box containing the range.
- `min_latitude` (number): Southern edge of the box containing the range.
- `min_longitude` (number): Western edge of the box containing the range.
- `origin` (object): The place the range was measured from.
- `time_budget_minutes` (number): The time budget used, when it was a time budget.
- `travel_mode` (text): The travel mode the range was measured for.

**Example output**

```json
{
  "boundary": [
    {
      "latitude": 52.5541,
      "longitude": 4.90943
    },
    {
      "latitude": 52.4903,
      "longitude": 5.1712
    },
    {
      "latitude": 52.2611,
      "longitude": 5.0433
    },
    {
      "latitude": 52.2004,
      "longitude": 4.7716
    }
  ],
  "boundary_point_count": 4,
  "center_latitude": 52.37727,
  "center_longitude": 4.90943,
  "distance_budget_km": null,
  "found": true,
  "max_latitude": 52.5541,
  "max_longitude": 5.1712,
  "min_latitude": 52.2004,
  "min_longitude": 4.7716,
  "origin": {
    "address": "De Ruijterkade 154, 1011 AC Amsterdam",
    "geocoded": true,
    "input": "De Ruijterkade 154, Amsterdam",
    "latitude": 52.37727,
    "longitude": 4.90943
  },
  "time_budget_minutes": 30.0,
  "travel_mode": "car"
}
```

### Calculate a route

Plan a route between two places, with any number of stops along the way, and get back the distance, the travel time with live traffic, how much of that time is delay, and where the delay is. Start, end and stops each take a plain address or coordinates, and an address is geocoded for you. Choose the vehicle (car, truck, bus, bicycle, on foot and more), what to optimise for, roads to avoid, a departure or arrival time, and whether to have the stops reordered into the shortest trip.

**Inputs**

- Start (`origin`, text, required): Where the route starts: an address, a place name, or 'latitude,longitude'.
- End (`destination`, text, required): Where the route ends: an address, a place name, or 'latitude,longitude'.
- Stops along the way (`waypoints`, list): Optional. Places to pass through between the start and the end, in order. Each one may be an address or 'latitude,longitude'.
- Travelling by (`travel_mode`, text): What the trip is made in or on. One of: `car`, `truck`, `taxi`, `bus`, `van`, `motorcycle`, `bicycle`, `pedestrian` (On foot). Default: `car`.
- Optimise for (`route_type`, text): Which of the possible routes to return. One of: `fastest` (Fastest (shortest travel time)), `shortest` (Shortest (shortest distance)), `eco` (Eco (balances time against fuel or energy used)), `thrilling` (Thrilling (winding roads and fewer motorways)). Default: `fastest`.
- Leaving at (`depart_at`, date and time): Optional. Plan the trip for this departure time, using the traffic expected then. Leave it empty to leave now.
- Arriving by (`arrive_at`, date and time): Optional. Work backwards from this arrival time to say when to leave. Cannot be combined with a departure time.
- Use live traffic (`use_traffic`, true/false): Take current and expected traffic into account. Turn it off for a time that ignores congestion entirely. Default: `true`.
- Avoid (`avoid`, list): Optional. Road types to keep off the route. One or more of: `tollRoads` (Toll roads), `motorways`, `ferries`, `unpavedRoads` (Unpaved roads), `carpools` (Carpool (HOV) lanes), `alreadyUsedRoads` (Roads already used on this route).
- Alternative routes (`max_alternatives`, number): How many other routes to return alongside the best one, for comparison. From 0 to 5. Default: `0`.
- Reorder the stops (`optimize_waypoint_order`, true/false): Let TomTom put the stops in the order that makes the trip shortest, instead of visiting them as listed. Only applies when there are stops. Default: `false`.
- Language (`language`, text): Optional. The language TomTom writes names and addresses in. Leave it empty for each place's local language. One of: `en-GB` (English (UK)), `en-US` (English (US)), `en-AU` (English (Australia)), `en-NZ` (English (New Zealand)), `af-ZA` (Afrikaans), `ar` (Arabic), `bg-BG` (Bulgarian), `ca-ES` (Catalan), `cs-CZ` (Czech), `da-DK` (Danish), and 36 more.

**Outputs**

- `alternative_count` (number): How many alternative routes came back.
- `alternative_routes` (list): A summary of each alternative route, when any were asked for.
- `arrival_time` (text): When the trip ends, in the destination's local time.
- `battery_consumption_kwh` (number): kWh used, when an electric model applies.
- `departure_time` (text): When the trip starts, in the origin's local time.
- `destination` (object): Where the route ends.
- `distance_meters` (number): Total distance in metres.
- `distance_text` (text): Total distance, written out: '51.2 km'.
- `found` (true/false): Whether a route was found.
- `fuel_consumption_liters` (number): Litres of fuel, when a combustion model applies.
- `legs` (list): One leg per pair of consecutive stops.
- `no_traffic_travel_time_seconds` (number): What the trip would take with no traffic at all.
- `origin` (object): Where the route starts.
- `route_type` (text): Which route was asked for: fastest, shortest, eco or thrilling.
- `traffic_delay_seconds` (number): How much of the travel time is traffic delay.
- `traffic_delay_text` (text): The traffic delay, written out.
- `traffic_sections` (list): Where along the route the traffic delay actually is.
- `travel_mode` (text): The travel mode the route was planned for.
- `travel_time_seconds` (number): Total travel time in seconds, including traffic.
- `travel_time_text` (text): Total travel time, written out: '1 h 15 min'.
- `waypoints` (list): The stops along the way, in the order they are visited.

**Example output**

```json
{
  "alternative_count": 0,
  "alternative_routes": [],
  "arrival_time": "2026-09-01T10:00:42+02:00",
  "battery_consumption_kwh": null,
  "departure_time": "2026-09-01T09:00:00+02:00",
  "destination": {
    "address": "",
    "geocoded": false,
    "input": "51.9225,4.47917",
    "latitude": 51.9225,
    "longitude": 4.47917
  },
  "distance_meters": 78413,
  "distance_text": "78.4 km",
  "found": true,
  "fuel_consumption_liters": 5.4,
  "legs": [
    {
      "arrival_time": "2026-09-01T10:00:42+02:00",
      "departure_time": "2026-09-01T09:00:00+02:00",
      "distance_meters": 78413,
      "distance_text": "78.4 km",
      "end_latitude": 51.9225,
      "end_longitude": 4.47917,
      "leg_number": 1,
      "start_latitude": 52.37727,
      "start_longitude": 4.90943,
      "traffic_delay_seconds": 421,
      "travel_time_seconds": 3642,
      "travel_time_text": "1 h"
    }
  ],
  "no_traffic_travel_time_seconds": 3221,
  "origin": {
    "address": "De Ruijterkade 154, 1011 AC Amsterdam",
    "geocoded": true,
    "input": "De Ruijterkade 154, Amsterdam",
    "latitude": 52.37727,
    "longitude": 4.90943
  },
  "route_type": "fastest",
  "traffic_delay_seconds": 421,
  "traffic_delay_text": "7 min",
  "traffic_sections": [
    {
      "category": "JAM",
      "delay_seconds": 421,
      "delay_text": "7 min",
      "effective_speed_kmh": 34,
      "magnitude_of_delay": 2
    }
  ],
  "travel_mode": "car",
  "travel_time_seconds": 3642,
  "travel_time_text": "1 h",
  "waypoints": []
}
```

### Geocode a structured address

Geocode an address that is already split into fields: street number, street, city, state, postcode, rather than written on one line. The right action when the address comes out of a CRM, a checkout form or a spreadsheet with a column per part: nothing has to be glued together first, and a city cannot be misread as part of the street. The country is required; give at least one other part.

**Inputs**

- Country (`country_code`, text, required): The country the address is in. Required. One of: `AF` (Afghanistan), `AX` (Åland Islands), `AL` (Albania), `DZ` (Algeria), `AD` (Andorra), `AO` (Angola), `AI` (Anguilla), `AQ` (Antarctica), `AG` (Antigua & Barbuda), `AR` (Argentina), and 239 more.
- Street number (`street_number`, text): Optional. The house or building number.
- Street (`street_name`, text): Optional. The street name, without the number.
- Cross street (`cross_street`, text): Optional. A cross street, for an address given as a junction rather than a number.
- City or town (`municipality`, text): Optional. The city or town.
- District (`municipality_subdivision`, text): Optional. A district or neighbourhood inside the city.
- State or province (`country_subdivision`, text): Optional. The state or province, as a name or a code ("California" or "CA").
- County (`country_secondary_subdivision`, text): Optional. The county or equivalent.
- Named area (`country_tertiary_subdivision`, text): Optional. A named area below county level, where a country uses one.
- Postcode (`postal_code`, text): Optional. The postcode or ZIP code.
- Language (`language`, text): Optional. The language TomTom writes names and addresses in. Leave it empty for each place's local language. One of: `en-GB` (English (UK)), `en-US` (English (US)), `en-AU` (English (Australia)), `en-NZ` (English (New Zealand)), `af-ZA` (Afrikaans), `ar` (Arabic), `bg-BG` (Bulgarian), `ca-ES` (Catalan), `cs-CZ` (Czech), `da-DK` (Danish), and 36 more.
- Geopolitical view (`view`, text): Optional. Which country's view of disputed borders to use. Leave it empty for the international one. One of: `Unified` (International (default)), `AR` (Argentina), `CN` (China), `IN` (India), `IL` (Israel), `MA` (Morocco), `PK` (Pakistan), `RS` (Serbia), `RU` (Russia), `TR` (Türkiye), `TW` (Taiwan).
- Results (`limit`, number): How many results to return at most. From 1 to 100. Default: `10`.

**Outputs**

- `address` (text): The best match's full address, as TomTom writes it.
- `country_code` (text): The best match's two-letter country code.
- `found` (true/false): Whether anything matched.
- `latitude` (number): Latitude of the best match, the field to feed a route.
- `longitude` (number): Longitude of the best match.
- `query` (text): The address that was looked up.
- `results` (list): Every match, most confident first.
- `returned_count` (number): How many matches came back.
- `total_count` (number): How many matches there are in total.

**Example output**

```json
{
  "address": "De Ruijterkade 154, 1011 AC Amsterdam",
  "country_code": "NL",
  "found": true,
  "latitude": 52.37727,
  "longitude": 4.90943,
  "query": "De Ruijterkade 154, 1011 AC, Amsterdam",
  "results": [
    {
      "address": "De Ruijterkade 154, 1011 AC Amsterdam",
      "country": "Netherlands",
      "country_code": "NL",
      "country_subdivision": "NH",
      "country_subdivision_name": "Noord-Holland",
      "entity_type": "",
      "id": "NL/PAD/p0/1234567",
      "latitude": 52.37727,
      "longitude": 4.90943,
      "match_score": 0.9959,
      "municipality": "Amsterdam",
      "municipality_subdivision": "Amsterdam-Centrum",
      "postal_code": "1011 AC",
      "street_name": "De Ruijterkade",
      "street_number": "154",
      "type": "Point Address",
      "viewport_bottom_right_latitude": 52.37637,
      "viewport_bottom_right_longitude": 4.91086,
      "viewport_top_left_latitude": 52.37817,
      "viewport_top_left_longitude": 4.908
    }
  ],
  "returned_count": 1,
  "total_count": 1
}
```

### Geocode an address

Turn a written address or place name into coordinates, with the address parsed into its parts and a confidence score for the match. The step that comes before mapping, routing or distance work on addresses out of a form, a CRM or a spreadsheet. Bias it towards a point or restrict it to a set of countries when the same street name exists in several places. Use 'Geocode a structured address' instead when the address already arrives split into fields.

**Inputs**

- Address (`address`, text, required): The address or place name to look up.
- Countries (`countries`, list): Optional. Only return results in these countries. Choose none to search the whole world. One or more of: `AF` (Afghanistan), `AX` (Åland Islands), `AL` (Albania), `DZ` (Algeria), `AD` (Andorra), `AO` (Angola), `AI` (Anguilla), `AQ` (Antarctica), `AG` (Antigua & Barbuda), `AR` (Argentina), and 239 more.
- Near latitude (`latitude`, number): Optional. Prefer results near this point. Give a longitude too. From -90.0 to 90.0.
- Near longitude (`longitude`, number): Optional. Prefer results near this point. Give a latitude too. From -180.0 to 180.0.
- Within (metres) (`radius_meters`, number): Optional. Only return results inside this many metres of the point above. Needs a latitude and longitude. From 1 to 500000.
- Only these levels (`entity_types`, list): Optional. Only return administrative areas of these levels, and no streets or addresses: the way to turn a name into a city or a state rather than a point on a road. One or more of: `Country`, `CountrySubdivision` (State or province), `CountrySecondarySubdivision` (County), `CountryTertiarySubdivision` (Named area), `Municipality` (City or town), `MunicipalitySubdivision` (District or neighbourhood), `Neighbourhood`, `PostalCodeArea` (Postcode area).
- Language (`language`, text): Optional. The language TomTom writes names and addresses in. Leave it empty for each place's local language. One of: `en-GB` (English (UK)), `en-US` (English (US)), `en-AU` (English (Australia)), `en-NZ` (English (New Zealand)), `af-ZA` (Afrikaans), `ar` (Arabic), `bg-BG` (Bulgarian), `ca-ES` (Catalan), `cs-CZ` (Czech), `da-DK` (Danish), and 36 more.
- Geopolitical view (`view`, text): Optional. Which country's view of disputed borders to use. Leave it empty for the international one. One of: `Unified` (International (default)), `AR` (Argentina), `CN` (China), `IN` (India), `IL` (Israel), `MA` (Morocco), `PK` (Pakistan), `RS` (Serbia), `RU` (Russia), `TR` (Türkiye), `TW` (Taiwan).
- Results (`limit`, number): How many results to return at most. From 1 to 100. Default: `10`.

**Outputs**

- `address` (text): The best match's full address, as TomTom writes it.
- `country_code` (text): The best match's two-letter country code.
- `found` (true/false): Whether anything matched.
- `latitude` (number): Latitude of the best match, the field to feed a route.
- `longitude` (number): Longitude of the best match.
- `query` (text): The address that was looked up.
- `results` (list): Every match, most confident first.
- `returned_count` (number): How many matches came back.
- `total_count` (number): How many matches there are in total.

**Example output**

```json
{
  "address": "De Ruijterkade 154, 1011 AC Amsterdam",
  "country_code": "NL",
  "found": true,
  "latitude": 52.37727,
  "longitude": 4.90943,
  "query": "De Ruijterkade 154, 1011 AC, Amsterdam",
  "results": [
    {
      "address": "De Ruijterkade 154, 1011 AC Amsterdam",
      "country": "Netherlands",
      "country_code": "NL",
      "country_subdivision": "NH",
      "country_subdivision_name": "Noord-Holland",
      "entity_type": "",
      "id": "NL/PAD/p0/1234567",
      "latitude": 52.37727,
      "longitude": 4.90943,
      "match_score": 0.9959,
      "municipality": "Amsterdam",
      "municipality_subdivision": "Amsterdam-Centrum",
      "postal_code": "1011 AC",
      "street_name": "De Ruijterkade",
      "street_number": "154",
      "type": "Point Address",
      "viewport_bottom_right_latitude": 52.37637,
      "viewport_bottom_right_longitude": 4.91086,
      "viewport_top_left_latitude": 52.37817,
      "viewport_top_left_longitude": 4.908
    }
  ],
  "returned_count": 1,
  "total_count": 1
}
```

### Get traffic incidents

The crashes, jams, closures and road works around a place right now, worst delay first, each with what happened, which road it is on, how long the delay is and how long it is expected to last. Give an address or coordinates and a radius: the bounding box TomTom needs is worked out for you. Filter to the kinds of incident you care about, to a minimum delay, or to road works planned for later rather than what is happening now.

**Inputs**

- Around (`center`, text, required): The place to look around: an address, a place name, or 'latitude,longitude'.
- Within (metres) (`radius_meters`, number): How far around that place to look. From 1 to 500000. Default: `5000`.
- Kinds of incident (`categories`, list): Optional. Only report these kinds. Choose none for all of them. One or more of: `Accident`, `Jam` (Traffic jam), `RoadWorks` (Road works), `RoadClosed` (Road closed), `LaneClosed` (Lane closed), `BrokenDownVehicle` (Broken-down vehicle), `DangerousConditions` (Dangerous conditions), `Rain`, `Ice`, `Fog`, and 3 more.
- When (`time_validity`, list): Whether to report what is happening now, what is planned for later, or both. Defaults to what is happening now. One or more of: `present` (Happening now), `future` (Planned for later).
- Only delays of at least (seconds) (`min_delay_seconds`, number): Optional. Ignore incidents causing less delay than this: a way to keep an alert to the ones worth acting on. From 0 to 86400. Default: `0`.
- Language (`language`, text): Optional. The language TomTom writes names and addresses in. Leave it empty for each place's local language. One of: `en-GB` (English (UK)), `en-US` (English (US)), `en-AU` (English (Australia)), `en-NZ` (English (New Zealand)), `af-ZA` (Afrikaans), `ar` (Arabic), `bg-BG` (Bulgarian), `ca-ES` (Catalan), `cs-CZ` (Czech), `da-DK` (Danish), and 36 more.
- Results (`limit`, number): How many incidents to return at most. From 1 to 200. Default: `50`.

**Outputs**

- `bounding_box` (object): The box the radius was turned into.
- `center` (object): The place that was looked around.
- `incidents` (list): The incidents found, worst delay first.
- `radius_meters` (number): The radius that was searched, in metres.
- `returned_count` (number): How many incidents came back.
- `total_count` (number): How many matched before the result cap was applied.
- `total_delay_seconds` (number): The delays of the returned incidents, added up.
- `total_delay_text` (text): The total delay, written out.
- `worst_delay_seconds` (number): The longest single delay.
- `worst_delay_text` (text): The longest single delay, written out.

**Example output**

```json
{
  "bounding_box": {
    "max_latitude": 52.41813,
    "max_longitude": 4.9643,
    "min_latitude": 52.32821,
    "min_longitude": 4.81702
  },
  "center": {
    "address": "Amsterdam, Noord-Holland",
    "geocoded": true,
    "input": "Amsterdam",
    "latitude": 52.37317,
    "longitude": 4.89066
  },
  "incidents": [
    {
      "category": "Traffic jam",
      "category_code": 6,
      "delay_magnitude": "Moderate",
      "delay_seconds": 421,
      "delay_text": "7 min",
      "description": "Stationary traffic",
      "end_time": "2026-08-28T09:15:00Z",
      "from": "A10 junction S114",
      "id": "0d9a1a2b3c4d5e6f7a8b9c0d1e2f3a4b",
      "last_report_time": "2026-08-28T08:02:00Z",
      "latitude": 52.38712,
      "length_meters": 1834.0,
      "length_text": "1.8 km",
      "longitude": 4.87914,
      "number_of_reports": 4,
      "probability": "certain",
      "road_numbers": [
        "A10"
      ],
      "start_time": "2026-08-28T07:41:00Z",
      "time_validity": "present",
      "to": "A10 junction S116"
    }
  ],
  "radius_meters": 5000,
  "returned_count": 1,
  "total_count": 1,
  "total_delay_seconds": 421,
  "total_delay_text": "7 min",
  "worst_delay_seconds": 421,
  "worst_delay_text": "7 min"
}
```

### List place categories

TomTom's whole catalogue of place categories, with the id each one is filtered by, the names it also goes by, and the sub-categories under it. Use it to turn a word a workflow receives, 'pharmacy' or 'car wash', into the category id the search actions filter on, or to see what can be asked for at all. One request returns every category; the search box filters them here, over both the names and their synonyms.

**Inputs**

- Matching (`query`, text): Optional. Only keep categories whose name or synonyms contain this word. Leave it empty for all of them.
- Language (`language`, text): Optional. The language TomTom writes names and addresses in. Leave it empty for each place's local language. One of: `en-GB` (English (UK)), `en-US` (English (US)), `en-AU` (English (Australia)), `en-NZ` (English (New Zealand)), `af-ZA` (Afrikaans), `ar` (Arabic), `bg-BG` (Bulgarian), `ca-ES` (Catalan), `cs-CZ` (Czech), `da-DK` (Danish), and 36 more.

**Outputs**

- `categories` (list): The matching categories, alphabetically.
- `query` (text): The word the list was filtered by, if any.
- `returned_count` (number): How many categories matched.
- `total_count` (number): How many categories TomTom publishes in total.

**Example output**

```json
{
  "categories": [
    {
      "child_category_ids": [
        7315002,
        7315003,
        7315005
      ],
      "id": 7315,
      "name": "RESTAURANT",
      "synonyms": [
        "eatery",
        "diner",
        "dining"
      ]
    },
    {
      "child_category_ids": [],
      "id": 9376002,
      "name": "RESTAURANT AREA",
      "synonyms": [
        "food court"
      ]
    }
  ],
  "query": "restaurant",
  "returned_count": 2,
  "total_count": 448
}
```

### Reverse geocode coordinates

Turn a latitude and longitude back into a street address, broken into its parts. What a GPS ping, a photo's location, a vehicle position or a map click needs before it can be shown to a person or matched against a record. Optionally return the posted speed limit for the road the point sits on, or pin the answer to an administrative level: the city or the state the point falls in rather than the street.

**Inputs**

- Latitude (`latitude`, number, required): The latitude to look up. From -90.0 to 90.0.
- Longitude (`longitude`, number, required): The longitude to look up. From -180.0 to 180.0.
- Search within (metres) (`radius_meters`, number): Optional. How far from the point to look for an address. TomTom uses 10 km when this is empty. From 1 to 500000.
- Include speed limit (`include_speed_limit`, true/false): Also return the posted speed limit for the road the point is on, where TomTom has one. Default: `false`.
- Answer with (`entity_type`, text): Optional. Return the administrative area the point falls in at this level instead of a street address. One of: `Country`, `CountrySubdivision` (State or province), `CountrySecondarySubdivision` (County), `CountryTertiarySubdivision` (Named area), `Municipality` (City or town), `MunicipalitySubdivision` (District or neighbourhood), `Neighbourhood`, `PostalCodeArea` (Postcode area).
- Language (`language`, text): Optional. The language TomTom writes names and addresses in. Leave it empty for each place's local language. One of: `en-GB` (English (UK)), `en-US` (English (US)), `en-AU` (English (Australia)), `en-NZ` (English (New Zealand)), `af-ZA` (Afrikaans), `ar` (Arabic), `bg-BG` (Bulgarian), `ca-ES` (Catalan), `cs-CZ` (Czech), `da-DK` (Danish), and 36 more.
- Geopolitical view (`view`, text): Optional. Which country's view of disputed borders to use. Leave it empty for the international one. One of: `Unified` (International (default)), `AR` (Argentina), `CN` (China), `IN` (India), `IL` (Israel), `MA` (Morocco), `PK` (Pakistan), `RS` (Serbia), `RU` (Russia), `TR` (Türkiye), `TW` (Taiwan).

**Outputs**

- `address` (text): The nearest address, on one line.
- `addresses` (list): Every address returned for the point.
- `country` (text): Country name.
- `country_code` (text): Two-letter country code.
- `country_subdivision` (text): State or province code.
- `found` (true/false): Whether an address was found there.
- `latitude` (number): The latitude that was looked up.
- `longitude` (number): The longitude that was looked up.
- `municipality` (text): City or town.
- `postal_code` (text): Postcode.
- `returned_count` (number): How many addresses came back.
- `speed_limit` (text): The posted speed limit, when it was asked for and TomTom has one.
- `street_name` (text): Street name.
- `street_number` (text): House or building number.

**Example output**

```json
{
  "address": "De Ruijterkade 154, 1011 AC Amsterdam",
  "addresses": [
    {
      "address": "De Ruijterkade 154, 1011 AC Amsterdam",
      "country": "Netherlands",
      "country_code": "NLD",
      "country_subdivision": "NH",
      "country_subdivision_name": "Noord-Holland",
      "id": "NL/PAD/p0/1234567",
      "latitude": 52.37727,
      "longitude": 4.90943,
      "match_type": "AddressPoint",
      "municipality": "Amsterdam",
      "municipality_subdivision": "Amsterdam-Centrum",
      "postal_code": "1011 AC",
      "speed_limit": "50.00 KPH",
      "street_name": "De Ruijterkade",
      "street_number": "154"
    }
  ],
  "country": "Netherlands",
  "country_code": "NLD",
  "country_subdivision": "NH",
  "found": true,
  "latitude": 52.37727,
  "longitude": 4.90943,
  "municipality": "Amsterdam",
  "postal_code": "1011 AC",
  "returned_count": 1,
  "speed_limit": "50.00 KPH",
  "street_name": "De Ruijterkade",
  "street_number": "154"
}
```

### Search nearby

What is around a coordinate, nearest first, with the distance to each one. The action for 'what is near this delivery address', 'which of our branches is closest to this postcode', or filling out a place a workflow only knows the position of. Filter it by category or brand to ask a narrower question.

**Inputs**

- Latitude (`latitude`, number, required): The latitude to search around. From -90.0 to 90.0.
- Longitude (`longitude`, number, required): The longitude to search around. From -180.0 to 180.0.
- Within (metres) (`radius_meters`, number): How far around the point to look. TomTom defaults to 10 km when this is left empty. From 1 to 500000.
- Place categories (`category_ids`, list): Optional. Only return places in these categories: restaurants, petrol stations, hotels and so on. The list comes from your connection.
- Brands (`brands`, list): Optional. Only return places belonging to these brands, spelled the way TomTom spells them ("Starbucks", "Shell"). A place's brands are on every result this integration returns.
- Open today only (`open_now`, true/false): Only keep places that are open at some point today. TomTom has no "open right now" filter, so this asks for the week's opening hours and keeps the places with an opening listed for today. Default: `false`.
- Language (`language`, text): Optional. The language TomTom writes names and addresses in. Leave it empty for each place's local language. One of: `en-GB` (English (UK)), `en-US` (English (US)), `en-AU` (English (Australia)), `en-NZ` (English (New Zealand)), `af-ZA` (Afrikaans), `ar` (Arabic), `bg-BG` (Bulgarian), `ca-ES` (Catalan), `cs-CZ` (Czech), `da-DK` (Danish), and 36 more.
- Results (`limit`, number): How many results to return at most. From 1 to 100. Default: `10`.
- Skip (`offset`, number): How many results to skip before the ones returned: set it to the previous step's 'next offset' to read the next page. From 0 to 1900. Default: `0`.

**Outputs**

- `has_more` (true/false): Whether more results are available after these.
- `latitude` (number): The latitude that was searched around.
- `longitude` (number): The longitude that was searched around.
- `next_offset` (number): The 'Skip' value that reads the next page, or nothing at the end.
- `offset` (number): How many results were skipped before these.
- `query` (text): What was searched for.
- `results` (list): The places found, best match first.
- `returned_count` (number): How many results came back.
- `total_count` (number): How many results match in total.

**Example output**

```json
{
  "has_more": true,
  "latitude": 52.37905,
  "longitude": 4.90019,
  "next_offset": 1,
  "offset": 0,
  "query": "52.37905,4.90019",
  "results": [
    {
      "address": "Stationsplein, 1012 AB Amsterdam",
      "brands": [
        "NS"
      ],
      "categories": [
        "public transport stop",
        "railroad station"
      ],
      "category_ids": [
        7380,
        7380002
      ],
      "country": "Netherlands",
      "country_code": "NL",
      "country_subdivision": "Noord-Holland",
      "distance_meters": 412.0,
      "id": "528009004256510",
      "latitude": 52.37905,
      "longitude": 4.90019,
      "municipality": "Amsterdam",
      "name": "Amsterdam Centraal",
      "opening_hours": [
        "2026-08-28 00:00\u201323:59"
      ],
      "phone": "+31 30 751 5155",
      "postal_code": "1012 AB",
      "score": 4.94,
      "street_name": "Stationsplein",
      "street_number": "",
      "time_zone": "Europe/Amsterdam",
      "type": "POI",
      "website": "https://www.ns.nl/"
    }
  ],
  "returned_count": 1,
  "total_count": 37
}
```

### Search places

Search TomTom's map for anything written as words: a business name, an address, a street, a city, or a mix of them. Returns each match with its coordinates, full address, phone, website, categories and brands. Narrow it to a point and a radius, to a set of countries, to particular categories or brands, or to places open today. This is the general search: use 'Search places by category' when you want every restaurant or petrol station in an area rather than a specific one.

**Inputs**

- Search for (`query`, text, required): What to look for: a name, an address, or both together.
- Near latitude (`latitude`, number): Optional. Prefer results near this point. Give a longitude too. From -90.0 to 90.0.
- Near longitude (`longitude`, number): Optional. Prefer results near this point. Give a latitude too. From -180.0 to 180.0.
- Within (metres) (`radius_meters`, number): Optional. Only return results inside this many metres of the point above. Needs a latitude and longitude. From 1 to 500000.
- Countries (`countries`, list): Optional. Only return results in these countries. Choose none to search the whole world. One or more of: `AF` (Afghanistan), `AX` (Åland Islands), `AL` (Albania), `DZ` (Algeria), `AD` (Andorra), `AO` (Angola), `AI` (Anguilla), `AQ` (Antarctica), `AG` (Antigua & Barbuda), `AR` (Argentina), and 239 more.
- Place categories (`category_ids`, list): Optional. Only return places in these categories: restaurants, petrol stations, hotels and so on. The list comes from your connection.
- Brands (`brands`, list): Optional. Only return places belonging to these brands, spelled the way TomTom spells them ("Starbucks", "Shell"). A place's brands are on every result this integration returns.
- Open today only (`open_now`, true/false): Only keep places that are open at some point today. TomTom has no "open right now" filter, so this asks for the week's opening hours and keeps the places with an opening listed for today. Default: `false`.
- Language (`language`, text): Optional. The language TomTom writes names and addresses in. Leave it empty for each place's local language. One of: `en-GB` (English (UK)), `en-US` (English (US)), `en-AU` (English (Australia)), `en-NZ` (English (New Zealand)), `af-ZA` (Afrikaans), `ar` (Arabic), `bg-BG` (Bulgarian), `ca-ES` (Catalan), `cs-CZ` (Czech), `da-DK` (Danish), and 36 more.
- Results (`limit`, number): How many results to return at most. From 1 to 100. Default: `10`.
- Skip (`offset`, number): How many results to skip before the ones returned: set it to the previous step's 'next offset' to read the next page. From 0 to 1900. Default: `0`.

**Outputs**

- `has_more` (true/false): Whether more results are available after these.
- `next_offset` (number): The 'Skip' value that reads the next page, or nothing at the end.
- `offset` (number): How many results were skipped before these.
- `query` (text): What was searched for.
- `results` (list): The places found, best match first.
- `returned_count` (number): How many results came back.
- `total_count` (number): How many results match in total.

**Example output**

```json
{
  "has_more": true,
  "next_offset": 1,
  "offset": 0,
  "query": "Amsterdam Centraal",
  "results": [
    {
      "address": "Stationsplein, 1012 AB Amsterdam",
      "brands": [
        "NS"
      ],
      "categories": [
        "public transport stop",
        "railroad station"
      ],
      "category_ids": [
        7380,
        7380002
      ],
      "country": "Netherlands",
      "country_code": "NL",
      "country_subdivision": "Noord-Holland",
      "distance_meters": 412.0,
      "id": "528009004256510",
      "latitude": 52.37905,
      "longitude": 4.90019,
      "municipality": "Amsterdam",
      "name": "Amsterdam Centraal",
      "opening_hours": [
        "2026-08-28 00:00\u201323:59"
      ],
      "phone": "+31 30 751 5155",
      "postal_code": "1012 AB",
      "score": 4.94,
      "street_name": "Stationsplein",
      "street_number": "",
      "time_zone": "Europe/Amsterdam",
      "type": "POI",
      "website": "https://www.ns.nl/"
    }
  ],
  "returned_count": 1,
  "total_count": 37
}
```

### Search places by category

Every place of a given kind in an area: all the petrol stations within 5 km, all the hotels in a city, all the EV charging points along a corridor. Pick the categories from the dropdown, which is filled from TomTom's own category tree, and optionally add words to narrow it further. Returns the same detail as 'Search places'.

**Inputs**

- Place categories (`category_ids`, list, required): The kinds of place to find. The list comes from your connection: pick one or several.
- Also matching (`query`, text): Optional. Extra words the place must match, on top of the categories: "24 hour", a brand, a street name.
- Near latitude (`latitude`, number): Optional. Prefer results near this point. Give a longitude too. From -90.0 to 90.0.
- Near longitude (`longitude`, number): Optional. Prefer results near this point. Give a latitude too. From -180.0 to 180.0.
- Within (metres) (`radius_meters`, number): Optional. Only return results inside this many metres of the point above. Needs a latitude and longitude. From 1 to 500000.
- Countries (`countries`, list): Optional. Only return results in these countries. Choose none to search the whole world. One or more of: `AF` (Afghanistan), `AX` (Åland Islands), `AL` (Albania), `DZ` (Algeria), `AD` (Andorra), `AO` (Angola), `AI` (Anguilla), `AQ` (Antarctica), `AG` (Antigua & Barbuda), `AR` (Argentina), and 239 more.
- Brands (`brands`, list): Optional. Only return places belonging to these brands, spelled the way TomTom spells them ("Starbucks", "Shell"). A place's brands are on every result this integration returns.
- Open today only (`open_now`, true/false): Only keep places that are open at some point today. TomTom has no "open right now" filter, so this asks for the week's opening hours and keeps the places with an opening listed for today. Default: `false`.
- Language (`language`, text): Optional. The language TomTom writes names and addresses in. Leave it empty for each place's local language. One of: `en-GB` (English (UK)), `en-US` (English (US)), `en-AU` (English (Australia)), `en-NZ` (English (New Zealand)), `af-ZA` (Afrikaans), `ar` (Arabic), `bg-BG` (Bulgarian), `ca-ES` (Catalan), `cs-CZ` (Czech), `da-DK` (Danish), and 36 more.
- Results (`limit`, number): How many results to return at most. From 1 to 100. Default: `10`.
- Skip (`offset`, number): How many results to skip before the ones returned: set it to the previous step's 'next offset' to read the next page. From 0 to 1900. Default: `0`.

**Outputs**

- `category_ids` (list): The category ids that were searched for.
- `has_more` (true/false): Whether more results are available after these.
- `next_offset` (number): The 'Skip' value that reads the next page, or nothing at the end.
- `offset` (number): How many results were skipped before these.
- `query` (text): What was searched for.
- `results` (list): The places found, best match first.
- `returned_count` (number): How many results came back.
- `total_count` (number): How many results match in total.

**Example output**

```json
{
  "category_ids": [
    7380
  ],
  "has_more": true,
  "next_offset": 1,
  "offset": 0,
  "query": "Amsterdam Centraal",
  "results": [
    {
      "address": "Stationsplein, 1012 AB Amsterdam",
      "brands": [
        "NS"
      ],
      "categories": [
        "public transport stop",
        "railroad station"
      ],
      "category_ids": [
        7380,
        7380002
      ],
      "country": "Netherlands",
      "country_code": "NL",
      "country_subdivision": "Noord-Holland",
      "distance_meters": 412.0,
      "id": "528009004256510",
      "latitude": 52.37905,
      "longitude": 4.90019,
      "municipality": "Amsterdam",
      "name": "Amsterdam Centraal",
      "opening_hours": [
        "2026-08-28 00:00\u201323:59"
      ],
      "phone": "+31 30 751 5155",
      "postal_code": "1012 AB",
      "score": 4.94,
      "street_name": "Stationsplein",
      "street_number": "",
      "time_zone": "Europe/Amsterdam",
      "type": "POI",
      "website": "https://www.ns.nl/"
    }
  ],
  "returned_count": 1,
  "total_count": 37
}
```