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

Calculate a route between two points

ParametersExpand Collapse
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
format_: String

Response format for alternatives: json (default), geojson, csv, ndjson

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
ReturnsExpand Collapse
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

Calculate a route between two points

require "plaza"

plaza = Plaza::Client.new(
  api_key: "My API Key",
  environment: "local" # defaults to "production"
)

route_result = plaza.routing.route(destination: {lat: 48.8584, lng: 2.2945}, origin: {lat: 48.8566, lng: 2.3522})

puts(route_result)
{
  "geometry": {
    "coordinates": [
      2.3522,
      48.8566
    ],
    "type": "Point"
  },
  "properties": {
    "distance_m": 4523.7,
    "duration_s": 847.2,
    "annotations": {
      "foo": "bar"
    },
    "charge_profile": [
      [
        0
      ]
    ],
    "charging_stops": [
      {
        "foo": "bar"
      }
    ],
    "edges": [
      {
        "foo": "bar"
      }
    ],
    "energy_used_wh": 0
  },
  "type": "Feature"
}
Returns Examples
{
  "geometry": {
    "coordinates": [
      2.3522,
      48.8566
    ],
    "type": "Point"
  },
  "properties": {
    "distance_m": 4523.7,
    "duration_s": 847.2,
    "annotations": {
      "foo": "bar"
    },
    "charge_profile": [
      [
        0
      ]
    ],
    "charging_stops": [
      {
        "foo": "bar"
      }
    ],
    "edges": [
      {
        "foo": "bar"
      }
    ],
    "energy_used_wh": 0
  },
  "type": "Feature"
}