Skip to content
Plaza Plaza Docs
GuidesBlogPlaygroundDashboard
API Reference

Routing

Calculate a route between two points
routing.route(**kwargs) -> RouteResult { geometry, properties, type }
POST/api/v1/route
Snap a coordinate to the nearest road
routing.nearest(**kwargs) -> NearestResult { geometry, properties, type }
GET/api/v1/nearest
Snap a coordinate to the nearest road
routing.nearest_post(**kwargs) -> NearestResult { geometry, properties, type }
POST/api/v1/nearest
Calculate an isochrone from a point
routing.isochrone(**kwargs) -> RoutingIsochroneResponse { features, geometry, properties, type }
GET/api/v1/isochrone
Calculate an isochrone from a point
routing.isochrone_post(**kwargs) -> RoutingIsochronePostResponse { features, geometry, properties, type }
POST/api/v1/isochrone
Calculate a distance matrix between points
routing.matrix(**kwargs) -> MatrixResult
POST/api/v1/matrix
ModelsExpand Collapse
class MatrixRequest { destinations, origins, annotations, 2 more }

Request body for distance matrix calculation. Computes travel durations (and optionally distances) between every origin-destination pair. Maximum 2,500 pairs (origins × destinations), each list capped at 50 coordinates.

destinations: Array[{ lat, lng}]

Array of destination coordinates (max 50)

lat: Float

Latitude in decimal degrees (-90 to 90)

maximum90
minimum-90
lng: Float

Longitude in decimal degrees (-180 to 180)

maximum180
minimum-180
origins: Array[{ lat, lng}]

Array of origin coordinates (max 50)

lat: Float

Latitude in decimal degrees (-90 to 90)

maximum90
minimum-90
lng: Float

Longitude in decimal degrees (-180 to 180)

maximum180
minimum-180
annotations: String

Comma-separated list of annotations to include: duration (always included), distance. Example: duration,distance.

fallback_speed: Float

Fallback speed in km/h for pairs where no route exists. When set, unreachable pairs get estimated values instead of null.

exclusiveMinimum
minimum0
mode: :auto | :foot | :bicycle

Travel mode (default: auto)

One of the following:
:auto
:foot
:bicycle
Hash[Symbol, untyped]

Distance matrix result. The exact response shape depends on the routing backend. Contains duration (and optionally distance) data for all origin-destination pairs. Null values indicate unreachable pairs.

class NearestResult { geometry, properties, type }

GeoJSON Point Feature representing the nearest point on the road network to the input coordinate. Used for snapping GPS coordinates to roads.

geometry: GeoJsonGeometry { coordinates, type }

GeoJSON Geometry object per RFC 7946. Coordinates use [longitude, latitude] order. 3D coordinates [lng, lat, elevation] are used for elevation endpoints.

coordinates: Array[Float] | Array[Array[Float]] | Array[Array[Array[Float]]] | Array[Array[Array[Array[Float]]]]

Coordinates array. Nesting depth varies by geometry type: Point = [lng, lat], LineString = [[lng, lat], ...], Polygon = [[[lng, lat], ...], ...], etc.

One of the following:
Array[Float]

[longitude, latitude] or [longitude, latitude, elevation]

Array[Array[Float]]

Array of [lng, lat] positions

Array[Array[Array[Float]]]

Array of linear rings / line strings

Array[Array[Array[Array[Float]]]]

Array of polygons

type: :Point | :LineString | :Polygon | 3 more

Geometry type

One of the following:
:Point
:LineString
:Polygon
:MultiPoint
:MultiLineString
:MultiPolygon
properties: { distance_m, edge_id, edge_length_m, 3 more}

Snap result metadata

distance_m: Float

Distance from the input coordinate to the snapped point in meters

edge_id: Integer

ID of the road network edge that was snapped to

edge_length_m: Float

Length of the matched road edge in meters

highway: String

OSM highway tag value (e.g. residential, primary, motorway)

osm_way_id: Integer

OSM way ID of the matched road segment

surface: String

OSM surface tag value (e.g. asphalt, gravel, paved)

type: :Feature
class RouteRequest { destination, origin, alternatives, 10 more }

Request body for route calculation. Origin and destination are lat/lng coordinate objects. Supports optional waypoints, alternative routes, turn-by-turn steps, and EV routing parameters.

destination: { lat, lng}

Geographic coordinate as a JSON object with lat and lng fields.

lat: Float

Latitude in decimal degrees (-90 to 90)

maximum90
minimum-90
lng: Float

Longitude in decimal degrees (-180 to 180)

maximum180
minimum-180
origin: { lat, lng}

Geographic coordinate as a JSON object with lat and lng fields.

lat: Float

Latitude in decimal degrees (-90 to 90)

maximum90
minimum-90
lng: Float

Longitude in decimal degrees (-180 to 180)

maximum180
minimum-180
alternatives: Integer

Number of alternative routes to return (0-3, default 0). When > 0, response is a FeatureCollection of route Features.

maximum3
minimum0
annotations: bool

Include per-edge annotations (speed, duration) on the route (default: false)

depart_at: Time

Departure time for traffic-aware routing (ISO 8601)

formatdate-time
ev: { battery_capacity_wh, connector_types, initial_charge_pct, 2 more}

Electric vehicle parameters for EV-aware routing

battery_capacity_wh: Float

Total battery capacity in watt-hours (required for EV routing)

connector_types: Array[String]

Acceptable connector types (e.g. ["ccs", "chademo"])

initial_charge_pct: Float

Starting charge as a fraction 0-1 (default: 0.8)

maximum1
minimum0
min_charge_pct: Float

Minimum acceptable charge at destination as a fraction 0-1 (default: 0.10)

maximum1
minimum0
min_power_kw: Float

Minimum charger power in kilowatts

exclude: String

Comma-separated road types to exclude (e.g. toll,motorway,ferry)

geometries: :geojson | :polyline | :polyline6

Geometry encoding format. Default: geojson.

One of the following:
:geojson
:polyline
:polyline6
mode: :auto | :foot | :bicycle

Travel mode (default: auto)

One of the following:
:auto
:foot
:bicycle
overview: :full | :simplified | :false

Level of geometry detail: full (all points), simplified (Douglas-Peucker), false (no geometry). Default: full.

One of the following:
:full
:simplified
:false
steps: bool

Include turn-by-turn navigation steps (default: false)

traffic_model: :best_guess | :optimistic | :pessimistic

Traffic prediction model (only used when depart_at is set)

One of the following:
:best_guess
:optimistic
:pessimistic
waypoints: Array[{ lat, lng}]

Intermediate waypoints to visit in order (maximum 25)

lat: Float

Latitude in decimal degrees (-90 to 90)

maximum90
minimum-90
lng: Float

Longitude in decimal degrees (-180 to 180)

maximum180
minimum-180
class RouteResult { geometry, properties, type }

GeoJSON Feature representing a calculated route. The geometry is a LineString or MultiLineString of the route path. When alternatives > 0, the response is a FeatureCollection containing multiple route Features.

geometry: GeoJsonGeometry { coordinates, type }

GeoJSON Geometry object per RFC 7946. Coordinates use [longitude, latitude] order. 3D coordinates [lng, lat, elevation] are used for elevation endpoints.

coordinates: Array[Float] | Array[Array[Float]] | Array[Array[Array[Float]]] | Array[Array[Array[Array[Float]]]]

Coordinates array. Nesting depth varies by geometry type: Point = [lng, lat], LineString = [[lng, lat], ...], Polygon = [[[lng, lat], ...], ...], etc.

One of the following:
Array[Float]

[longitude, latitude] or [longitude, latitude, elevation]

Array[Array[Float]]

Array of [lng, lat] positions

Array[Array[Array[Float]]]

Array of linear rings / line strings

Array[Array[Array[Array[Float]]]]

Array of polygons

type: :Point | :LineString | :Polygon | 3 more

Geometry type

One of the following:
:Point
:LineString
:Polygon
:MultiPoint
:MultiLineString
:MultiPolygon
properties: { distance_m, duration_s, annotations, 4 more}

Route metadata

distance_m: Float

Total route distance in meters

duration_s: Float

Estimated travel duration in seconds

annotations: Hash[Symbol, untyped]

Per-edge annotations (present when annotations: true in request)

charge_profile: Array[Array[Float]]

Battery charge level at route waypoints as [distance_fraction, charge_pct] pairs (EV routes only)

charging_stops: Array[Hash[Symbol, untyped]]

Recommended charging stops along the route (EV routes only)

edges: Array[Hash[Symbol, untyped]]

Edge-level route details (present when annotations: true)

energy_used_wh: Float

Total energy consumed in watt-hours (EV routes only)

type: :Feature