# Valhalla

> Plan routes on OpenStreetMap data with Valhalla, the open-source routing engine behind the directions on openstreetmap.org, through the free public server run by FOSSGIS. Get turn-by-turn directions by car, bicycle, on foot, by truck, motorcycle or bus in 29 languages, put a round of stops in the quickest order, work out travel times between many places, map the area reachable within a time or distance, find the nearest road and its speed limit, get elevations along a line, match GPS traces to roads, and find a fair meeting point. Places are given as latitude and longitude. No account or API key required.

App · 10 actions. Web page: https://docs.lodol.com/docs/integrations/valhalla

## Actions

### Check the routing server

Check that the public Valhalla server is answering, which version it runs and when its OpenStreetMap data was last rebuilt, which is how up to date the roads it routes on are. No API key required.

**Inputs**: None.

**Outputs**

- `data_age_days` (number): How many days ago that was.
- `data_updated_at` (text): When the server's OpenStreetMap data was last rebuilt (UTC).
- `online` (true/false): Whether the server answered.
- `server_url` (text): The server's address.
- `services` (list): The services the server offers.
- `summary` (text): One readable sentence saying what came back.
- `version` (text): The Valhalla version the server runs.

**Example output**

```json
{
  "data_age_days": 0,
  "data_updated_at": "2026-10-21T16:50:55Z",
  "online": true,
  "server_url": "https://valhalla1.openstreetmap.de",
  "services": [
    "route",
    "locate",
    "sources_to_targets",
    "optimized_route",
    "isochrone",
    "trace_route",
    "trace_attributes",
    "height",
    "transit_available",
    "expansion",
    "centroid",
    "status",
    "tile"
  ],
  "summary": "Valhalla 3.9.1-618cad5 is answering; its OpenStreetMap data was rebuilt on 2026-10-21 (0 days ago).",
  "version": "3.9.1-618cad5"
}
```

### Find a meeting point

Find a fair place for 2 to 5 people to meet: the point on the road network everyone can reach soonest, with each person's travel time and distance to it and a link to it on OpenStreetMap. No API key required.

**Inputs**

- Starting places (`places`, text, required): Where each person sets off from: 2 to 5 places. One place per line as latitude, longitude in decimal degrees, latitude first, such as 52.5163, 13.3777. Start a line with a name and a colon (Office: 52.5163, 13.3777) to see that name in the results. Valhalla needs coordinates: to start from an address, look it up first with OpenStreetMap Nominatim and pass its result here.
- Travel mode (`travel_mode`, text): How the trip is made. Car by default. Each mode keeps to the roads and paths open to it: a truck avoids roads closed to heavy vehicles, a bicycle prefers cycle lanes, walking uses footpaths. One of: `auto` (Car), `bicycle`, `pedestrian` (Walking), `truck`, `motor_scooter` (Motor scooter or moped), `motorcycle`, `bus`, `taxi`. Default: `auto`.
- Distance units (`units`, text): Kilometres or miles for every distance in the result. Kilometres by default. One of: `kilometers` (Kilometres), `miles`. Default: `kilometers`.

**Outputs**

- `journeys` (list): Each person's journey to the meeting point, in the order given.
- `longest_duration_seconds` (number): The longest journey's time, in seconds.
- `longest_duration_text` (text): The longest journey's time in words.
- `meeting_point` (object): The meeting point.
- `summary` (text): One readable sentence saying what came back.
- `total_distance` (number): Everyone's distances added up.
- `total_distance_text` (text): That total in words.
- `total_duration_seconds` (number): Everyone's journey times added up, in seconds.
- `travel_mode` (text): The travel mode used: auto (car), bicycle, pedestrian (walking), truck, motor_scooter, motorcycle, bus or taxi.
- `units` (text): The distance units used: 'kilometers' or 'miles'.

**Example output**

```json
{
  "journeys": [
    {
      "distance": 1.412,
      "distance_text": "1.4 km",
      "duration_seconds": 125,
      "duration_text": "2 min",
      "encoded_polyline": "k|idcBckpoXdtB}rN`pGxaA",
      "label": "Brandenburg Gate",
      "latitude": 52.516275,
      "longitude": 13.377704,
      "position": 1
    },
    {
      "distance": 2.957,
      "distance_text": "3.0 km",
      "duration_seconds": 218,
      "duration_text": "4 min",
      "encoded_polyline": "qzvdcBcuuqXv}N|dMtdH|qh@",
      "label": "Alexanderplatz",
      "latitude": 52.521918,
      "longitude": 13.413215,
      "position": 2
    },
    {
      "distance": 3.819,
      "distance_text": "3.8 km",
      "duration_seconds": 222,
      "duration_text": "4 min",
      "encoded_polyline": "}~zdcBiy|nXbjQu_Bt|Iga]",
      "label": "Hauptbahnhof",
      "latitude": 52.525084,
      "longitude": 13.369402,
      "position": 3
    }
  ],
  "longest_duration_seconds": 222,
  "longest_duration_text": "4 min",
  "meeting_point": {
    "latitude": 52.510065,
    "longitude": 13.385172,
    "map_url": "https://www.openstreetmap.org/?mlat=52.510065&mlon=13.385172#map=17/52.510065/13.385172"
  },
  "summary": "Meeting point at 52.510065, 13.385172. Brandenburg Gate: 2 min; Alexanderplatz: 4 min; Hauptbahnhof: 4 min. Longest journey 4 min by car.",
  "total_distance": 8.188,
  "total_distance_text": "8.2 km",
  "total_duration_seconds": 565,
  "travel_mode": "auto",
  "units": "kilometers"
}
```

### Find the nearest road

Snap up to 50 points to the nearest road or path the travel mode can use, and get each road's name, OpenStreetMap id, class (motorway, residential...), surface, speed limit, lanes, whether it is one way, a toll road, a tunnel or a bridge, and who may use it. A point with no usable road nearby comes back with 'found' false rather than failing the step. No API key required.

**Inputs**

- Points (`points`, text, required): The points to look up, up to 50. One place per line as latitude, longitude in decimal degrees, latitude first, such as 52.5163, 13.3777. Start a line with a name and a colon (Office: 52.5163, 13.3777) to see that name in the results. Valhalla needs coordinates: to start from an address, look it up first with OpenStreetMap Nominatim and pass its result here.
- Travel mode (`travel_mode`, text): How the trip is made. Car by default. Each mode keeps to the roads and paths open to it: a truck avoids roads closed to heavy vehicles, a bicycle prefers cycle lanes, walking uses footpaths. One of: `auto` (Car), `bicycle`, `pedestrian` (Walking), `truck`, `motor_scooter` (Motor scooter or moped), `motorcycle`, `bus`, `taxi`. Default: `auto`.

**Outputs**

- `count` (number): How many points were looked up.
- `found_count` (number): How many had a road nearby.
- `points` (list): One row per point, in the order given.
- `summary` (text): One readable sentence saying what came back.
- `travel_mode` (text): The travel mode used: auto (car), bicycle, pedestrian (walking), truck, motor_scooter, motorcycle, bus or taxi.

**Example output**

```json
{
  "count": 2,
  "found_count": 1,
  "points": [
    {
      "allowed_modes": [
        "car",
        "truck",
        "bus",
        "taxi",
        "motorcycle",
        "moped",
        "bicycle",
        "pedestrian",
        "wheelchair",
        "carpool"
      ],
      "bridge": false,
      "cycle_lane": "none",
      "default_speed_kmh": 10,
      "distance_meters": 36.6,
      "found": true,
      "heading": 353.8,
      "input_latitude": 52.516275,
      "input_longitude": 13.377704,
      "label": "Brandenburg Gate",
      "lanes": 1,
      "latitude": 52.51631,
      "longitude": 13.378242,
      "mean_elevation_m": 38.0,
      "one_way": false,
      "osm_url": "https://www.openstreetmap.org/way/154043356",
      "position": 1,
      "road_class": "service_other",
      "road_name": "Pariser Platz",
      "roundabout": false,
      "side_of_street": "left",
      "sidewalk": "none",
      "speed_limit_kmh": 20,
      "street_names": [
        "Pariser Platz"
      ],
      "surface": "paved",
      "toll": false,
      "tunnel": false,
      "use": "service_road",
      "way_id": 154043356
    },
    {
      "allowed_modes": [],
      "bridge": null,
      "cycle_lane": null,
      "default_speed_kmh": null,
      "distance_meters": null,
      "found": false,
      "heading": null,
      "input_latitude": 54.5,
      "input_longitude": 5.0,
      "label": "At sea",
      "lanes": null,
      "latitude": null,
      "longitude": null,
      "mean_elevation_m": null,
      "one_way": null,
      "osm_url": null,
      "position": 2,
      "road_class": null,
      "road_name": null,
      "roundabout": null,
      "side_of_street": null,
      "sidewalk": null,
      "speed_limit_kmh": null,
      "street_names": [],
      "surface": null,
      "toll": null,
      "tunnel": null,
      "use": null,
      "way_id": null
    }
  ],
  "summary": "Found a road near 1 of 2 points.",
  "travel_mode": "auto"
}
```

### Get directions

Plan a route through 2 to 10 stops, in order, by car, bicycle, on foot, by truck, motor scooter, motorcycle, bus or taxi. Get the total distance and travel time, every turn-by-turn instruction in any of 29 languages, and the route's line as coordinates and GeoJSON for a map. Set a time to leave or to arrive by and get the clock times back, avoid toll roads, motorways, ferries, unpaved roads or particular spots, and ask for up to two alternative routes. No API key required.

**Inputs**

- Stops (`stops`, text, required): Where the trip starts, any stops on the way and where it ends, in order: 2 to 10 places. One place per line as latitude, longitude in decimal degrees, latitude first, such as 52.5163, 13.3777. Start a line with a name and a colon (Office: 52.5163, 13.3777) to see that name in the results. Valhalla needs coordinates: to start from an address, look it up first with OpenStreetMap Nominatim and pass its result here.
- Travel mode (`travel_mode`, text): How the trip is made. Car by default. Each mode keeps to the roads and paths open to it: a truck avoids roads closed to heavy vehicles, a bicycle prefers cycle lanes, walking uses footpaths. One of: `auto` (Car), `bicycle`, `pedestrian` (Walking), `truck`, `motor_scooter` (Motor scooter or moped), `motorcycle`, `bus`, `taxi`. Default: `auto`.
- Distance units (`units`, text): Kilometres or miles for every distance in the result. Kilometres by default. One of: `kilometers` (Kilometres), `miles`. Default: `kilometers`.
- Directions language (`language`, text): The language the turn-by-turn instructions are written in. English (United States) by default. One of: `en-US` (English (United States)), `en-GB` (English (United Kingdom)), `bg-BG` (Bulgarian), `ca-ES` (Catalan), `cs-CZ` (Czech), `da-DK` (Danish), `de-DE` (German), `el-GR` (Greek), `es-ES` (Spanish), `et-EE` (Estonian), and 19 more. Default: `en-US`.
- Avoid (`avoid`, list): Kinds of road to stay off where there is another way. Valhalla still uses one when nothing else gets there. Toll roads and motorways only matter to motor vehicles. One or more of: `tolls` (Toll roads), `highways` (Motorways and highways), `ferries`, `unpaved` (Unpaved roads).
- Places to avoid (`avoid_points`, text): Spots to route around, such as a closed bridge or a roadworks site: up to 50, one per line as latitude, longitude. Valhalla avoids the road nearest each one.
- Leave at (`depart_at`, date and time): When to set off. The result then says when you arrive, in the local time at the last stop, and roads closed at that time are avoided. Leave both times empty to plan without one.
- Arrive by (`arrive_by`, date and time): When to get there, instead of a time to leave. The result says when to set off, in the local time at the first stop.
- Alternative routes (`alternatives`, number): How many other routes to suggest as well, up to 2. Valhalla offers them only between two stops with no time set, and may find fewer. From 0 to 2. Default: `0`.
- Include the line (`include_geometry`, true/false): Return the route's line as coordinates and as GeoJSON, ready for a map. On by default. Turn it off for long routes when only the distance, time and directions are needed; the encoded polyline is always returned. Default: `true`.

**Outputs**

- `alternatives` (list): Other routes Valhalla found, when alternatives were asked for.
- `arrival_time` (text): When the trip arrives, in the local time at the last stop with its UTC offset. Empty when no time was given.
- `bounding_box` (object): The smallest box around the line or area. Empty when there is none.
- `coordinates` (list): The line as [latitude, longitude] pairs. Empty when 'Include the line' is off.
- `departure_time` (text): When the trip leaves, in the local time at the first stop with its UTC offset, such as 2026-10-21T08:00+02:00. Empty when no time was given.
- `directions_text` (text): Every instruction as numbered lines with its distance, ready to put in a message.
- `distance` (number): The total distance, in the units asked for.
- `distance_meters` (number): The total distance in metres.
- `distance_text` (text): The total distance in words, such as '2.7 km'.
- `duration_seconds` (number): The total travel time, in seconds.
- `duration_text` (text): The total travel time in words, such as '7 min' or '1 h 5 min'.
- `encoded_polyline` (text): The whole line as an encoded polyline with six decimal places, which the GPS trace and elevation actions take as input.
- `geojson` (object): The line as a GeoJSON Feature (a LineString, [longitude, latitude] order) for a map. Empty when 'Include the line' is off.
- `has_ferry` (true/false): Whether the trip takes a ferry.
- `has_highway` (true/false): Whether the trip uses a motorway or highway.
- `has_toll` (true/false): Whether the trip uses a toll road.
- `legs` (list): Each part of the trip between two stops.
- `maneuver_count` (number): How many instructions there are.
- `maneuvers` (list): Every turn-by-turn instruction, in order.
- `stops` (list): The stops, in the order they are visited.
- `summary` (text): One readable sentence saying what came back.
- `time_zone` (text): The time zone the given time was read in, such as Europe/Berlin. Empty when no time was given.
- `travel_mode` (text): The travel mode used: auto (car), bicycle, pedestrian (walking), truck, motor_scooter, motorcycle, bus or taxi.
- `units` (text): The distance units used: 'kilometers' or 'miles'.
- `warnings` (list): Notes about how the trip was planned, if any.

**Example output**

```json
{
  "alternatives": [],
  "arrival_time": "2026-10-21T08:07+02:00",
  "bounding_box": {
    "max_latitude": 52.523893,
    "max_longitude": 13.413966,
    "min_latitude": 52.51618,
    "min_longitude": 13.378242
  },
  "coordinates": [
    [
      52.51631,
      13.378242
    ],
    [
      52.517608,
      13.399178
    ],
    [
      52.522937,
      13.41373
    ]
  ],
  "departure_time": "2026-10-21T08:00+02:00",
  "directions_text": "1. Drive south on Pariser Platz. (10 m)\n2. Turn left to stay on Pariser Platz. (2.6 km)\n3. Turn right onto Alexanderstra\u00dfe/B 2/B 5. (150 m)\n4. Turn right. (20 m)\n5. Alexanderplatz is on the left.",
  "distance": 2.748,
  "distance_meters": 2748,
  "distance_text": "2.7 km",
  "duration_seconds": 434,
  "duration_text": "7 min",
  "encoded_polyline": "k|idcBckpoXcpAo{g@alIol[",
  "geojson": {
    "geometry": {
      "coordinates": [
        [
          13.378242,
          52.51631
        ],
        [
          13.399178,
          52.517608
        ],
        [
          13.41373,
          52.522937
        ]
      ],
      "type": "LineString"
    },
    "properties": {
      "distance_meters": 2748,
      "duration_seconds": 434,
      "travel_mode": "auto"
    },
    "type": "Feature"
  },
  "has_ferry": false,
  "has_highway": false,
  "has_toll": false,
  "legs": [
    {
      "distance": 2.748,
      "distance_text": "2.7 km",
      "duration_seconds": 434,
      "duration_text": "7 min",
      "from_label": "Brandenburg Gate",
      "maneuver_count": 5,
      "position": 1,
      "to_label": "Alexanderplatz"
    }
  ],
  "maneuver_count": 5,
  "maneuvers": [
    {
      "distance": 0.014,
      "distance_text": "10 m",
      "duration_seconds": 5,
      "instruction": "Drive south on Pariser Platz.",
      "kind": "start_right",
      "latitude": 52.51631,
      "leg": 1,
      "longitude": 13.378242,
      "step": 1,
      "street_names": [
        "Pariser Platz"
      ],
      "travel_type": "car"
    },
    {
      "distance": 2.557,
      "distance_text": "2.6 km",
      "duration_seconds": 387,
      "instruction": "Turn left to stay on Pariser Platz.",
      "kind": "turn_left",
      "latitude": 52.516181,
      "leg": 1,
      "longitude": 13.378265,
      "step": 2,
      "street_names": [
        "Pariser Platz"
      ],
      "travel_type": "car"
    },
    {
      "distance": 0.152,
      "distance_text": "150 m",
      "duration_seconds": 22,
      "instruction": "Turn right onto Alexanderstra\u00dfe/B 2/B 5.",
      "kind": "turn_right",
      "latitude": 52.523893,
      "leg": 1,
      "longitude": 13.412151,
      "step": 3,
      "street_names": [
        "Alexanderstra\u00dfe",
        "B 2",
        "B 5"
      ],
      "travel_type": "car"
    },
    {
      "distance": 0.024,
      "distance_text": "20 m",
      "duration_seconds": 20,
      "instruction": "Turn right.",
      "kind": "turn_right",
      "latitude": 52.523106,
      "leg": 1,
      "longitude": 13.413966,
      "step": 4,
      "street_names": [],
      "travel_type": "car"
    },
    {
      "distance": 0.0,
      "distance_text": "0 m",
      "duration_seconds": 0,
      "instruction": "Alexanderplatz is on the left.",
      "kind": "destination_left",
      "latitude": 52.522937,
      "leg": 1,
      "longitude": 13.41373,
      "step": 5,
      "street_names": [],
      "travel_type": "car"
    }
  ],
  "stops": [
    {
      "input_position": 1,
      "label": "Brandenburg Gate",
      "latitude": 52.516275,
      "longitude": 13.377704,
      "position": 1,
      "side_of_street": "right"
    },
    {
      "input_position": 2,
      "label": "Alexanderplatz",
      "latitude": 52.521918,
      "longitude": 13.413215,
      "position": 2,
      "side_of_street": "left"
    }
  ],
  "summary": "2.7 km, about 7 min by car from Brandenburg Gate to Alexanderplatz. Leaves 2026-10-21T08:00+02:00, arrives 2026-10-21T08:07+02:00.",
  "time_zone": "Europe/Berlin",
  "travel_mode": "auto",
  "units": "kilometers",
  "warnings": []
}
```

### Get elevation

Get the height of the ground above sea level at up to 5,000 points, or every so many metres along a line such as a route from 'Get directions'. Returns each point's height and distance along the line, the lowest and highest points, and the total climb and descent. No API key required.

**Inputs**

- Points (`points`, text, required): The points to measure, in order along the line: one per line as latitude, longitude, or an encoded polyline with six decimal places such as the one 'Get directions' returns.
- Sample every (metres) (`sample_every`, number): Measure at even steps of this many metres along the line instead of only at the points given, for an elevation profile. Leave empty to measure only the points. From 10 to 100000.
- Units (`units`, text): Metres and kilometres, or feet and miles. Metric by default. One of: `kilometers` (Metres and kilometres), `miles` (Feet and miles). Default: `kilometers`.

**Outputs**

- `count` (number): How many points came back.
- `distance_unit` (text): The unit distances are in: 'km' or 'mi'.
- `elevation_unit` (text): The unit heights are in: 'm' or 'ft'.
- `encoded_polyline` (text): The points as an encoded polyline (six decimals).
- `end_elevation` (number): The last point's height.
- `max_elevation` (number): The highest height.
- `min_elevation` (number): The lowest height.
- `missing_count` (number): How many points have no height data (usually at sea).
- `points` (list): One row per point, along the line in order.
- `start_elevation` (number): The first point's height.
- `summary` (text): One readable sentence saying what came back.
- `total_ascent` (number): The total climb along the line.
- `total_descent` (number): The total descent along the line.
- `total_distance` (number): The line's length, in km or miles.
- `units` (text): The distance units used: 'kilometers' or 'miles'.

**Example output**

```json
{
  "count": 3,
  "distance_unit": "km",
  "elevation_unit": "m",
  "encoded_polyline": "ezidcBoiooXu_JmjdA{dEhqtA",
  "end_elevation": 22.0,
  "max_elevation": 38.0,
  "min_elevation": 22.0,
  "missing_count": 0,
  "points": [
    {
      "distance_from_start": 0.0,
      "elevation": 38.0,
      "label": "Brandenburg Gate",
      "latitude": 52.516275,
      "longitude": 13.377704,
      "position": 1
    },
    {
      "distance_from_start": 2.486,
      "elevation": 36.9,
      "label": "Alexanderplatz",
      "latitude": 52.521918,
      "longitude": 13.413215,
      "position": 2
    },
    {
      "distance_from_start": 5.474,
      "elevation": 22.0,
      "label": "Hauptbahnhof",
      "latitude": 52.525084,
      "longitude": 13.369402,
      "position": 3
    }
  ],
  "start_elevation": 38.0,
  "summary": "3 points: lowest 22 m, highest 38 m, 0 m of climb and 16 m of descent over 5.474 km.",
  "total_ascent": 0.0,
  "total_descent": 16.0,
  "total_distance": 5.474,
  "units": "kilometers"
}
```

### Get reachable area

Map the area someone can reach from a place within a travel time (up to 60 minutes) or a distance (up to 100 km), by any travel mode, also called an isochrone. Returns the area as GeoJSON polygons ready for a map, with each ring's size in km² and how far it reaches, and checks whether a list of points (customers, sites, homes) falls inside. Split it into up to four rings, or turn it round to see where people can reach the place from. No API key required.

**Inputs**

- Place (`center`, text, required): The place to measure from, as latitude, longitude, such as 52.5163, 13.3777. Put a name and a colon first to see it in the result.
- Travel time limit (minutes) (`minutes`, number): How many minutes of travel the area covers, up to 60. Fill this or the distance limit, not both. From 1 to 60.
- Travel distance limit (km) (`kilometers`, number): How many kilometres of travel along roads the area covers, up to 100. Fill this or the time limit, not both. From 0.1 to 100.
- Rings (`rings`, number): Split the limit into this many evenly spaced rings, up to 4: 30 minutes in 3 rings gives 10, 20 and 30 minutes. 1 by default. From 1 to 4. Default: `1`.
- Travel mode (`travel_mode`, text): How the trip is made. Car by default. Each mode keeps to the roads and paths open to it: a truck avoids roads closed to heavy vehicles, a bicycle prefers cycle lanes, walking uses footpaths. One of: `auto` (Car), `bicycle`, `pedestrian` (Walking), `truck`, `motor_scooter` (Motor scooter or moped), `motorcycle`, `bus`, `taxi`. Default: `auto`.
- Direction (`direction`, text): Leaving from the place (where can I get to?) by default, or arriving at it (where can people come from in time?), which differs where streets are one way. One of: `from` (Leaving from the place), `to` (Arriving at the place). Default: `from`.
- Points to check (`points_to_check`, text): Up to 100 points to test against the area, one per line as latitude, longitude with an optional name and colon first. Each comes back saying whether it is inside and in which ring.

**Outputs**

- `center` (object): The place the area is measured from.
- `checked_points` (list): The points you asked to check, each with whether it lies inside.
- `contours` (list): One row per ring, smallest first.
- `direction` (text): 'from' (where you can get to from the place) or 'to' (where you can get to the place from).
- `geojson` (object): The rings as a GeoJSON FeatureCollection of polygons ([longitude, latitude] order), largest first, ready for a map.
- `inside_count` (number): How many checked points are inside.
- `measure` (text): 'time' (limited by minutes) or 'distance' (limited by km).
- `summary` (text): One readable sentence saying what came back.
- `travel_mode` (text): The travel mode used: auto (car), bicycle, pedestrian (walking), truck, motor_scooter, motorcycle, bus or taxi.

**Example output**

```json
{
  "center": {
    "label": "Brandenburg Gate",
    "latitude": 52.516275,
    "longitude": 13.377704
  },
  "checked_points": [
    {
      "inside": false,
      "label": "Alexanderplatz",
      "latitude": 52.521918,
      "longitude": 13.413215,
      "within_label": null,
      "within_limit": null
    },
    {
      "inside": true,
      "label": "Reichstag",
      "latitude": 52.518623,
      "longitude": 13.376198,
      "within_label": "15 min",
      "within_limit": 15.0
    }
  ],
  "contours": [
    {
      "area_km2": 3.271,
      "bounding_box": {
        "max_latitude": 52.525928,
        "max_longitude": 13.396047,
        "min_latitude": 52.505692,
        "min_longitude": 13.360222
      },
      "color": "#bf4040",
      "farthest_km": 1.25,
      "label": "15 min",
      "limit": 15.0,
      "unit": "minutes"
    }
  ],
  "direction": "from",
  "geojson": {
    "features": [
      {
        "geometry": {
          "coordinates": [
            [
              [
                13.379704,
                52.525896
              ],
              [
                13.361101,
                52.516275
              ],
              [
                13.381704,
                52.507985
              ],
              [
                13.379704,
                52.525896
              ]
            ]
          ],
          "type": "Polygon"
        },
        "properties": {
          "color": "#bf4040",
          "contour": 15.0,
          "fill": "#bf4040",
          "fill-opacity": 0.33,
          "fillColor": "#bf4040",
          "fillOpacity": 0.33,
          "metric": "time",
          "opacity": 0.33
        },
        "type": "Feature"
      }
    ],
    "type": "FeatureCollection"
  },
  "inside_count": 1,
  "measure": "time",
  "summary": "Reachable on foot from Brandenburg Gate within 15 min: 3.271 km\u00b2, reaching up to 1.25 km away. 1 of 2 checked points are inside.",
  "travel_mode": "pedestrian"
}
```

### Get road details along a GPS trace

Match a GPS trace to roads and list every road it ran along, in order, with its name, speed limit, class, surface, lanes, length, grades and whether it is a toll road, tunnel or bridge, plus the regions it passed through. Useful for checking speeds against limits or reporting where a vehicle went. No API key required.

**Inputs**

- GPS trace (`trace`, text, required): The recorded points in the order they were recorded, one per line as latitude, longitude, up to 5,000 points no more than 10 km apart. An encoded polyline with six decimal places works too, such as the one 'Get directions' returns.
- Travel mode (`travel_mode`, text): How the trip is made. Car by default. Each mode keeps to the roads and paths open to it: a truck avoids roads closed to heavy vehicles, a bicycle prefers cycle lanes, walking uses footpaths. One of: `auto` (Car), `bicycle`, `pedestrian` (Walking), `truck`, `motor_scooter` (Motor scooter or moped), `motorcycle`, `bus`, `taxi`. Default: `auto`.
- Distance units (`units`, text): Kilometres or miles for every distance in the result. Kilometres by default. One of: `kilometers` (Kilometres), `miles`. Default: `kilometers`.

**Outputs**

- `distance` (number): The matched length, in the units asked for.
- `distance_text` (text): The matched length in words.
- `encoded_polyline` (text): The matched line as an encoded polyline (six decimals).
- `input_point_count` (number): How many GPS points were given.
- `interpolated_point_count` (number): How many points sat so close to the one before that they were placed between matched points.
- `matched_point_count` (number): How many points were matched to a road.
- `max_speed_limit` (number): The highest posted speed limit along the trace.
- `regions` (list): The states and countries the trace passes through.
- `road_count` (number): How many roads the trace ran along.
- `roads` (list): Each road the trace ran along, in order. Stretches of the same road are joined; a road that changes name, class, surface or speed limit part way is listed again from there.
- `speed_unit` (text): The unit speeds are in: 'km/h' or 'mph'.
- `summary` (text): One readable sentence saying what came back.
- `travel_mode` (text): The travel mode used: auto (car), bicycle, pedestrian (walking), truck, motor_scooter, motorcycle, bus or taxi.
- `units` (text): The distance units used: 'kilometers' or 'miles'.
- `unmatched_point_count` (number): How many points could not be matched to any road.

**Example output**

```json
{
  "distance": 2.748,
  "distance_text": "2.7 km",
  "encoded_polyline": "y|idcBakpoXuoAq{g@alIol[",
  "input_point_count": 150,
  "interpolated_point_count": 79,
  "matched_point_count": 71,
  "max_speed_limit": 50,
  "regions": [
    "Berlin, Deutschland"
  ],
  "road_count": 11,
  "roads": [
    {
      "bridge": false,
      "cycle_lane": "none",
      "lanes": 1,
      "length": 0.101,
      "length_text": "100 m",
      "max_down_grade": -4.0,
      "max_up_grade": 5.0,
      "mean_elevation_m": 38.0,
      "name": "Pariser Platz",
      "osm_url": "https://www.openstreetmap.org/way/154043356",
      "position": 1,
      "road_class": "service_other",
      "roundabout": false,
      "sidewalk": "none",
      "speed": 10,
      "speed_limit": 20,
      "street_names": [
        "Pariser Platz"
      ],
      "surface": "paved",
      "toll": false,
      "tunnel": false,
      "unpaved": false,
      "use": "service_road",
      "way_id": 154043356
    },
    {
      "bridge": false,
      "cycle_lane": "none",
      "lanes": 2,
      "length": 0.014,
      "length_text": "10 m",
      "max_down_grade": 0.0,
      "max_up_grade": 3.0,
      "mean_elevation_m": 38.0,
      "name": "Unter den Linden",
      "osm_url": "https://www.openstreetmap.org/way/424323348",
      "position": 2,
      "road_class": "residential",
      "roundabout": false,
      "sidewalk": "none",
      "speed": 16,
      "speed_limit": 20,
      "street_names": [
        "Unter den Linden"
      ],
      "surface": "paved",
      "toll": false,
      "tunnel": false,
      "unpaved": false,
      "use": "road",
      "way_id": 424323348
    },
    {
      "bridge": false,
      "cycle_lane": "none",
      "lanes": 2,
      "length": 0.077,
      "length_text": "80 m",
      "max_down_grade": -4.0,
      "max_up_grade": 5.0,
      "mean_elevation_m": 42.0,
      "name": "Unter den Linden",
      "osm_url": "https://www.openstreetmap.org/way/1476805843",
      "position": 3,
      "road_class": "residential",
      "roundabout": false,
      "sidewalk": "none",
      "speed": 16,
      "speed_limit": 20,
      "street_names": [
        "Unter den Linden"
      ],
      "surface": "paved_smooth",
      "toll": false,
      "tunnel": false,
      "unpaved": false,
      "use": "road",
      "way_id": 1476805843
    }
  ],
  "speed_unit": "km/h",
  "summary": "Matched 150 GPS points to 11 roads over 2.7 km in Berlin, Deutschland. Speed limits 20 to 50 km/h.",
  "travel_mode": "auto",
  "units": "kilometers",
  "unmatched_point_count": 0
}
```

### Get travel times between places

Work out the travel time and distance from each of a list of origins to each of a list of destinations, up to 100 journeys at once, for example to find the nearest depot to each customer. Every journey comes back as a row, with the quickest destination for each origin picked out. Leave the destinations empty to compare every place in one list with every other. No API key required.

**Inputs**

- Origins (`origins`, text, required): Where the journeys start. One place per line as latitude, longitude in decimal degrees, latitude first, such as 52.5163, 13.3777. Start a line with a name and a colon (Office: 52.5163, 13.3777) to see that name in the results. Valhalla needs coordinates: to start from an address, look it up first with OpenStreetMap Nominatim and pass its result here.
- Destinations (`destinations`, text): Where the journeys end, in the same format. Leave empty to use the origins, which compares every place with every other. Origins times destinations can be at most 100.
- Travel mode (`travel_mode`, text): How the trip is made. Car by default. Each mode keeps to the roads and paths open to it: a truck avoids roads closed to heavy vehicles, a bicycle prefers cycle lanes, walking uses footpaths. One of: `auto` (Car), `bicycle`, `pedestrian` (Walking), `truck`, `motor_scooter` (Motor scooter or moped), `motorcycle`, `bus`, `taxi`. Default: `auto`.
- Distance units (`units`, text): Kilometres or miles for every distance in the result. Kilometres by default. One of: `kilometers` (Kilometres), `miles`. Default: `kilometers`.
- Avoid (`avoid`, list): Kinds of road to stay off where there is another way. Valhalla still uses one when nothing else gets there. Toll roads and motorways only matter to motor vehicles. One or more of: `tolls` (Toll roads), `highways` (Motorways and highways), `ferries`, `unpaved` (Unpaved roads).

**Outputs**

- `destination_count` (number): How many destinations there are.
- `nearest` (list): For each origin, the destination it reaches soonest.
- `origin_count` (number): How many origins there are.
- `pair_count` (number): How many journeys were worked out.
- `pairs` (list): One row per journey, every origin to every destination, origin by origin.
- `summary` (text): One readable sentence saying what came back.
- `travel_mode` (text): The travel mode used: auto (car), bicycle, pedestrian (walking), truck, motor_scooter, motorcycle, bus or taxi.
- `units` (text): The distance units used: 'kilometers' or 'miles'.
- `unreachable_count` (number): How many journeys have no route.
- `warnings` (list): Notes about how the journeys were worked out, if any.

**Example output**

```json
{
  "destination_count": 2,
  "nearest": [
    {
      "destination_label": "Potsdamer Platz",
      "destination_position": 2,
      "distance": 1.578,
      "distance_text": "1.6 km",
      "duration_seconds": 272,
      "duration_text": "5 min",
      "origin_label": "Brandenburg Gate",
      "origin_position": 1
    },
    {
      "destination_label": "Potsdamer Platz",
      "destination_position": 2,
      "distance": 3.645,
      "distance_text": "3.6 km",
      "duration_seconds": 547,
      "duration_text": "9 min",
      "origin_label": "Alexanderplatz",
      "origin_position": 2
    }
  ],
  "origin_count": 2,
  "pair_count": 4,
  "pairs": [
    {
      "destination_label": "Hauptbahnhof",
      "destination_position": 1,
      "distance": 3.343,
      "distance_meters": 3343,
      "distance_text": "3.3 km",
      "duration_seconds": 494,
      "duration_text": "8 min",
      "origin_label": "Brandenburg Gate",
      "origin_position": 1,
      "reachable": true
    },
    {
      "destination_label": "Potsdamer Platz",
      "destination_position": 2,
      "distance": 1.578,
      "distance_meters": 1578,
      "distance_text": "1.6 km",
      "duration_seconds": 272,
      "duration_text": "5 min",
      "origin_label": "Brandenburg Gate",
      "origin_position": 1,
      "reachable": true
    },
    {
      "destination_label": "Hauptbahnhof",
      "destination_position": 1,
      "distance": 5.74,
      "distance_meters": 5740,
      "distance_text": "5.7 km",
      "duration_seconds": 799,
      "duration_text": "13 min",
      "origin_label": "Alexanderplatz",
      "origin_position": 2,
      "reachable": true
    },
    {
      "destination_label": "Potsdamer Platz",
      "destination_position": 2,
      "distance": 3.645,
      "distance_meters": 3645,
      "distance_text": "3.6 km",
      "duration_seconds": 547,
      "duration_text": "9 min",
      "origin_label": "Alexanderplatz",
      "origin_position": 2,
      "reachable": true
    }
  ],
  "summary": "4 journeys by car from 2 origins to 2 destinations.",
  "travel_mode": "auto",
  "units": "kilometers",
  "unreachable_count": 0,
  "warnings": [
    "Some journeys use roads open only to local traffic, because there was no other way to reach the place."
  ]
}
```

### Match a GPS trace to roads

Snap a recorded GPS trace onto the roads it followed and turn it into a route: the distance and time along the roads, turn-by-turn instructions and a clean line for a map. Useful for tidying up a recorded trip or describing it in words. No API key required.

**Inputs**

- GPS trace (`trace`, text, required): The recorded points in the order they were recorded, one per line as latitude, longitude, up to 5,000 points no more than 10 km apart. An encoded polyline with six decimal places works too, such as the one 'Get directions' returns.
- Travel mode (`travel_mode`, text): How the trip is made. Car by default. Each mode keeps to the roads and paths open to it: a truck avoids roads closed to heavy vehicles, a bicycle prefers cycle lanes, walking uses footpaths. One of: `auto` (Car), `bicycle`, `pedestrian` (Walking), `truck`, `motor_scooter` (Motor scooter or moped), `motorcycle`, `bus`, `taxi`. Default: `auto`.
- Distance units (`units`, text): Kilometres or miles for every distance in the result. Kilometres by default. One of: `kilometers` (Kilometres), `miles`. Default: `kilometers`.
- Directions language (`language`, text): The language the turn-by-turn instructions are written in. English (United States) by default. One of: `en-US` (English (United States)), `en-GB` (English (United Kingdom)), `bg-BG` (Bulgarian), `ca-ES` (Catalan), `cs-CZ` (Czech), `da-DK` (Danish), `de-DE` (German), `el-GR` (Greek), `es-ES` (Spanish), `et-EE` (Estonian), and 19 more. Default: `en-US`.
- Include the line (`include_geometry`, true/false): Return the route's line as coordinates and as GeoJSON, ready for a map. On by default. Turn it off for long routes when only the distance, time and directions are needed; the encoded polyline is always returned. Default: `true`.

**Outputs**

- `bounding_box` (object): The smallest box around the line or area. Empty when there is none.
- `coordinates` (list): The line as [latitude, longitude] pairs. Empty when 'Include the line' is off.
- `directions_text` (text): Every instruction as numbered lines with its distance, ready to put in a message.
- `distance` (number): The total distance, in the units asked for.
- `distance_meters` (number): The total distance in metres.
- `distance_text` (text): The total distance in words, such as '2.7 km'.
- `duration_seconds` (number): The total travel time, in seconds.
- `duration_text` (text): The total travel time in words, such as '7 min' or '1 h 5 min'.
- `encoded_polyline` (text): The whole line as an encoded polyline with six decimal places, which the GPS trace and elevation actions take as input.
- `geojson` (object): The line as a GeoJSON Feature (a LineString, [longitude, latitude] order) for a map. Empty when 'Include the line' is off.
- `has_ferry` (true/false): Whether the trip takes a ferry.
- `has_highway` (true/false): Whether the trip uses a motorway or highway.
- `has_toll` (true/false): Whether the trip uses a toll road.
- `input_point_count` (number): How many GPS points were matched.
- `legs` (list): Each part of the trip between two stops.
- `maneuver_count` (number): How many instructions there are.
- `maneuvers` (list): Every turn-by-turn instruction, in order.
- `stops` (list): The stops, in the order they are visited.
- `summary` (text): One readable sentence saying what came back.
- `travel_mode` (text): The travel mode used: auto (car), bicycle, pedestrian (walking), truck, motor_scooter, motorcycle, bus or taxi.
- `units` (text): The distance units used: 'kilometers' or 'miles'.
- `warnings` (list): Notes about how the trip was planned, if any.

**Example output**

```json
{
  "bounding_box": {
    "max_latitude": 52.523893,
    "max_longitude": 13.413966,
    "min_latitude": 52.51618,
    "min_longitude": 13.378241
  },
  "coordinates": [
    [
      52.516317,
      13.378241
    ],
    [
      52.517608,
      13.399178
    ],
    [
      52.522937,
      13.41373
    ]
  ],
  "directions_text": "1. Drive south on Pariser Platz. (20 m)\n2. Turn left to stay on Pariser Platz. (2.6 km)\n3. Turn right onto Alexanderstra\u00dfe/B 2/B 5. (150 m)\n4. Turn right. (20 m)\n5. You have arrived at your destination.",
  "distance": 2.749,
  "distance_meters": 2749,
  "distance_text": "2.7 km",
  "duration_seconds": 434,
  "duration_text": "7 min",
  "encoded_polyline": "y|idcBakpoXuoAq{g@alIol[",
  "geojson": {
    "geometry": {
      "coordinates": [
        [
          13.378241,
          52.516317
        ],
        [
          13.399178,
          52.517608
        ],
        [
          13.41373,
          52.522937
        ]
      ],
      "type": "LineString"
    },
    "properties": {
      "distance_meters": 2749,
      "duration_seconds": 434,
      "travel_mode": "auto"
    },
    "type": "Feature"
  },
  "has_ferry": false,
  "has_highway": false,
  "has_toll": false,
  "input_point_count": 3,
  "legs": [
    {
      "distance": 2.749,
      "distance_text": "2.7 km",
      "duration_seconds": 434,
      "duration_text": "7 min",
      "from_label": "Start of the trace",
      "maneuver_count": 5,
      "position": 1,
      "to_label": "End of the trace"
    }
  ],
  "maneuver_count": 5,
  "maneuvers": [
    {
      "distance": 0.015,
      "distance_text": "20 m",
      "duration_seconds": 5,
      "instruction": "Drive south on Pariser Platz.",
      "kind": "start",
      "latitude": 52.516317,
      "leg": 1,
      "longitude": 13.378241,
      "step": 1,
      "street_names": [
        "Pariser Platz"
      ],
      "travel_type": "car"
    },
    {
      "distance": 2.557,
      "distance_text": "2.6 km",
      "duration_seconds": 387,
      "instruction": "Turn left to stay on Pariser Platz.",
      "kind": "turn_left",
      "latitude": 52.516181,
      "leg": 1,
      "longitude": 13.378265,
      "step": 2,
      "street_names": [
        "Pariser Platz"
      ],
      "travel_type": "car"
    },
    {
      "distance": 0.152,
      "distance_text": "150 m",
      "duration_seconds": 22,
      "instruction": "Turn right onto Alexanderstra\u00dfe/B 2/B 5.",
      "kind": "turn_right",
      "latitude": 52.523893,
      "leg": 1,
      "longitude": 13.412151,
      "step": 3,
      "street_names": [
        "Alexanderstra\u00dfe",
        "B 2",
        "B 5"
      ],
      "travel_type": "car"
    },
    {
      "distance": 0.024,
      "distance_text": "20 m",
      "duration_seconds": 20,
      "instruction": "Turn right.",
      "kind": "turn_right",
      "latitude": 52.523106,
      "leg": 1,
      "longitude": 13.413966,
      "step": 4,
      "street_names": [],
      "travel_type": "car"
    },
    {
      "distance": 0.0,
      "distance_text": "0 m",
      "duration_seconds": 0,
      "instruction": "You have arrived at your destination.",
      "kind": "destination",
      "latitude": 52.522937,
      "leg": 1,
      "longitude": 13.41373,
      "step": 5,
      "street_names": [],
      "travel_type": "car"
    }
  ],
  "stops": [
    {
      "input_position": 1,
      "label": "Start of the trace",
      "latitude": 52.51631,
      "longitude": 13.378242,
      "position": 1,
      "side_of_street": null
    },
    {
      "input_position": 2,
      "label": "End of the trace",
      "latitude": 52.522937,
      "longitude": 13.41373,
      "position": 2,
      "side_of_street": null
    }
  ],
  "summary": "Matched 3 GPS points to 2.7 km of road, about 7 min by car, in 5 steps.",
  "travel_mode": "auto",
  "units": "kilometers",
  "warnings": []
}
```

### Optimize stop order

Find the quickest order to visit 3 to 10 stops, such as a delivery or sales round. The first stop stays first and the last stays last, or turn on 'Return to the start' for a round trip, and every stop in between is visited once. Returns the new order, the total distance and time, and the turn-by-turn directions in that order. No API key required.

**Inputs**

- Stops (`stops`, text, required): The stops to put in order: 3 to 10 places, starting with where the round begins (9 with a round trip). One place per line as latitude, longitude in decimal degrees, latitude first, such as 52.5163, 13.3777. Start a line with a name and a colon (Office: 52.5163, 13.3777) to see that name in the results. Valhalla needs coordinates: to start from an address, look it up first with OpenStreetMap Nominatim and pass its result here.
- Return to the start (`return_to_start`, true/false): Finish back at the first stop, for a round trip. Off by default, which keeps your last stop last. Default: `false`.
- Travel mode (`travel_mode`, text): How the trip is made. Car by default. Each mode keeps to the roads and paths open to it: a truck avoids roads closed to heavy vehicles, a bicycle prefers cycle lanes, walking uses footpaths. One of: `auto` (Car), `bicycle`, `pedestrian` (Walking), `truck`, `motor_scooter` (Motor scooter or moped), `motorcycle`, `bus`, `taxi`. Default: `auto`.
- Distance units (`units`, text): Kilometres or miles for every distance in the result. Kilometres by default. One of: `kilometers` (Kilometres), `miles`. Default: `kilometers`.
- Directions language (`language`, text): The language the turn-by-turn instructions are written in. English (United States) by default. One of: `en-US` (English (United States)), `en-GB` (English (United Kingdom)), `bg-BG` (Bulgarian), `ca-ES` (Catalan), `cs-CZ` (Czech), `da-DK` (Danish), `de-DE` (German), `el-GR` (Greek), `es-ES` (Spanish), `et-EE` (Estonian), and 19 more. Default: `en-US`.
- Avoid (`avoid`, list): Kinds of road to stay off where there is another way. Valhalla still uses one when nothing else gets there. Toll roads and motorways only matter to motor vehicles. One or more of: `tolls` (Toll roads), `highways` (Motorways and highways), `ferries`, `unpaved` (Unpaved roads).
- Include the line (`include_geometry`, true/false): Return the route's line as coordinates and as GeoJSON, ready for a map. On by default. Turn it off for long routes when only the distance, time and directions are needed; the encoded polyline is always returned. Default: `true`.

**Outputs**

- `bounding_box` (object): The smallest box around the line or area. Empty when there is none.
- `coordinates` (list): The line as [latitude, longitude] pairs. Empty when 'Include the line' is off.
- `directions_text` (text): Every instruction as numbered lines with its distance, ready to put in a message.
- `distance` (number): The total distance, in the units asked for.
- `distance_meters` (number): The total distance in metres.
- `distance_text` (text): The total distance in words, such as '2.7 km'.
- `duration_seconds` (number): The total travel time, in seconds.
- `duration_text` (text): The total travel time in words, such as '7 min' or '1 h 5 min'.
- `encoded_polyline` (text): The whole line as an encoded polyline with six decimal places, which the GPS trace and elevation actions take as input.
- `geojson` (object): The line as a GeoJSON Feature (a LineString, [longitude, latitude] order) for a map. Empty when 'Include the line' is off.
- `has_ferry` (true/false): Whether the trip takes a ferry.
- `has_highway` (true/false): Whether the trip uses a motorway or highway.
- `has_toll` (true/false): Whether the trip uses a toll road.
- `legs` (list): Each part of the trip between two stops.
- `maneuver_count` (number): How many instructions there are.
- `maneuvers` (list): Every turn-by-turn instruction, in order.
- `optimized_order` (list): The best order, as the positions the stops had in your list: [1, 3, 2, 4] means visit your third stop second.
- `order_text` (text): The stops' names in the best order, such as 'A, then C, then B'.
- `stops` (list): The stops, in the order they are visited.
- `summary` (text): One readable sentence saying what came back.
- `travel_mode` (text): The travel mode used: auto (car), bicycle, pedestrian (walking), truck, motor_scooter, motorcycle, bus or taxi.
- `units` (text): The distance units used: 'kilometers' or 'miles'.
- `warnings` (list): Notes about how the trip was planned, if any.

**Example output**

```json
{
  "bounding_box": {
    "max_latitude": 52.528969,
    "max_longitude": 13.416265,
    "min_latitude": 52.50924,
    "min_longitude": 13.367543
  },
  "coordinates": [
    [
      52.51631,
      13.378242
    ],
    [
      52.510891,
      13.395558
    ],
    [
      52.509665,
      13.376577
    ]
  ],
  "directions_text": "1. Drive south on Pariser Platz. (10 m)\n2. Turn left to stay on Pariser Platz. (2.6 km)\n3. Turn right onto Alexanderstra\u00dfe/B 2/B 5. (150 m)",
  "distance": 11.624,
  "distance_meters": 11624,
  "distance_text": "11.6 km",
  "duration_seconds": 1620,
  "duration_text": "27 min",
  "encoded_polyline": "k|idcBckpoXtqIgy`@rkAhad@",
  "geojson": {
    "geometry": {
      "coordinates": [
        [
          13.378242,
          52.51631
        ],
        [
          13.395558,
          52.510891
        ],
        [
          13.376577,
          52.509665
        ]
      ],
      "type": "LineString"
    },
    "properties": {
      "distance_meters": 11624,
      "duration_seconds": 1620,
      "travel_mode": "auto"
    },
    "type": "Feature"
  },
  "has_ferry": false,
  "has_highway": false,
  "has_toll": false,
  "legs": [
    {
      "distance": 2.748,
      "distance_text": "2.7 km",
      "duration_seconds": 434,
      "duration_text": "7 min",
      "from_label": "Brandenburg Gate",
      "maneuver_count": 5,
      "position": 1,
      "to_label": "Alexanderplatz"
    },
    {
      "distance": 5.739,
      "distance_text": "5.7 km",
      "duration_seconds": 800,
      "duration_text": "13 min",
      "from_label": "Alexanderplatz",
      "maneuver_count": 8,
      "position": 2,
      "to_label": "Hauptbahnhof"
    },
    {
      "distance": 3.136,
      "distance_text": "3.1 km",
      "duration_seconds": 387,
      "duration_text": "6 min",
      "from_label": "Hauptbahnhof",
      "maneuver_count": 8,
      "position": 3,
      "to_label": "Potsdamer Platz"
    }
  ],
  "maneuver_count": 3,
  "maneuvers": [
    {
      "distance": 0.014,
      "distance_text": "10 m",
      "duration_seconds": 5,
      "instruction": "Drive south on Pariser Platz.",
      "kind": "start_right",
      "latitude": 52.51631,
      "leg": 1,
      "longitude": 13.378242,
      "step": 1,
      "street_names": [
        "Pariser Platz"
      ],
      "travel_type": "car"
    },
    {
      "distance": 2.557,
      "distance_text": "2.6 km",
      "duration_seconds": 387,
      "instruction": "Turn left to stay on Pariser Platz.",
      "kind": "turn_left",
      "latitude": 52.516181,
      "leg": 1,
      "longitude": 13.378265,
      "step": 2,
      "street_names": [
        "Pariser Platz"
      ],
      "travel_type": "car"
    },
    {
      "distance": 0.152,
      "distance_text": "150 m",
      "duration_seconds": 22,
      "instruction": "Turn right onto Alexanderstra\u00dfe/B 2/B 5.",
      "kind": "turn_right",
      "latitude": 52.523893,
      "leg": 1,
      "longitude": 13.412151,
      "step": 3,
      "street_names": [
        "Alexanderstra\u00dfe",
        "B 2",
        "B 5"
      ],
      "travel_type": "car"
    }
  ],
  "optimized_order": [
    1,
    2,
    3,
    4
  ],
  "order_text": "Brandenburg Gate, then Alexanderplatz, then Hauptbahnhof, then Potsdamer Platz",
  "stops": [
    {
      "input_position": 1,
      "label": "Brandenburg Gate",
      "latitude": 52.516275,
      "longitude": 13.377704,
      "position": 1,
      "side_of_street": "right"
    },
    {
      "input_position": 2,
      "label": "Alexanderplatz",
      "latitude": 52.521918,
      "longitude": 13.413215,
      "position": 2,
      "side_of_street": "left"
    },
    {
      "input_position": 3,
      "label": "Hauptbahnhof",
      "latitude": 52.525084,
      "longitude": 13.369402,
      "position": 3,
      "side_of_street": "right"
    },
    {
      "input_position": 4,
      "label": "Potsdamer Platz",
      "latitude": 52.509663,
      "longitude": 13.376481,
      "position": 4,
      "side_of_street": "right"
    }
  ],
  "summary": "Best order: Brandenburg Gate, then Alexanderplatz, then Hauptbahnhof, then Potsdamer Platz. 11.6 km, about 27 min by car.",
  "travel_mode": "auto",
  "units": "kilometers",
  "warnings": [
    "Valhalla relaxed some road restrictions (such as roads open only to local traffic) to find this route."
  ]
}
```
