Developer Guide

Introduction

The Distance Matrix API is a service that provides travel distance and time for
a matrix of origins and destinations. The API returns information based on the recommended
route between start and end points, as calculated by the Google Maps API, and consists of rows
containing duration and distance values for each pair.

Note: This service does not return detailed route
information. Route information can be obtained by passing the desired single origin and
destination to the
Directions API.

Before you begin

This document is intended for developers who wish to compute travel distance and time between
a number of points within maps provided by one of the Google Maps APIs. It provides an
introduction to using the API and reference material on the available parameters.

Note: URLs must be
properly encoded to be valid and are limited to 8192 characters for all web services.
Be aware of this limit when constructing your URLs. Note that different browsers,
proxies, and servers may have different URL character limits as well.

HTTPS or HTTP

Security is important and HTTPS is recommended whenever possible,
especially for applications that include sensitive user data, such as a user's location,
in requests. Using HTTPS encryption makes your application more secure, and more
resistant to snooping or tampering.

If HTTPS is not possible, to access the Distance Matrix API over HTTP, use:

Request Parameters

Certain parameters are required while others are optional. As is standard in URLs, all
parameters are separated using the ampersand (&) character.

Required parameters

origins — The starting point for calculating travel distance
and time. You can supply one or more locations separated by the pipe character
(|), in the form of an address, latitude/longitude coordinates, or a place ID:

If you pass an address, the service geocodes the string and converts it to
a latitude/longitude coordinate to calculate distance. This coordinate may be
different from that returned by the Geocoding API, for example a building
entrance rather than its center.

origins=Bobcaygeon+ON|24+Sussex+Drive+Ottawa+ON

If you pass latitude/longitude coordinates, they are used unchanged
to calculate distance. Ensure that no space exists between the latitude
and longitude values.

origins=41.43206,-81.38992|-33.86748,151.20699

If you supply a place ID, you must prefix it with place_id:. You can
only specify a place ID if the request includes an API key or a
Google Maps APIs Premium Plan client ID. You can retrieve place IDs from
the Geocoding API and the Places SDK (including Place
Autocomplete). For an example using place IDs from Place Autocomplete, see
Place
Autocomplete and Directions. For more about place IDs, see the
place ID overview.

origins=place_id:ChIJ3S-JXmauEmsRUcIaWtf4MzE

Alternatively, you can supply an encoded set of coordinates using the
Encoded
Polyline Algorithm. This is particularly useful if you have a large
number of origin points, because the URL is significantly shorter when
using an encoded polyline.

Encoded polylines must be prefixed with enc: and
followed by a colon (:).For example:
origins=enc:gfo}EtohhU:

You can also include multiple encoded polylines, separated by the pipe
character (|). For example:
origins=enc:wc~oAwquwMdlTxiKtqLyiK:|enc:c~vnAamswMvlTor@tjGi}L:|enc:udymA{~bxM:

destinations — One or more locations to use as the finishing point
for calculating travel distance and time. The options for the destinations
parameter are the same as for the origins parameter, described above.

key — Your application's API key. This key identifies
your application for purposes of quota management. Learn how to
get a key.

If language is not supplied, the API attempts to use
the preferred language as specified in the
Accept-Language header, or the native language of the
domain from which the request is sent.

The API does its best to provide a street address that is
readable for both the user and locals. To achieve that goal, it
returns street addresses in the local language, transliterated to a
script readable by the user if necessary, observing the preferred
language. All other addresses are returned in the preferred
language. Address components are all returned in the same language,
which is chosen from the first component.

If a name is not available in the preferred language, the API uses the
closest match.

The preferred language has a small influence on the set of results that
the API chooses to return, and the order in which they are returned.
The geocoder interprets abbreviations differently depending on
language, such as the abbreviations for street types, or synonyms that may
be valid in one language but not in another. For example, utca
and tér are synonyms for street in Hungarian.

region — The region code, specified as a
ccTLD
(country code top-level domain) two-character value. Most ccTLD codes are
identical to ISO 3166-1 codes, with some exceptions. This parameter will
only influence, not fully restrict, results from the geocoder. If more
relevant results exist outside of the specified region, they may be
included.

avoid — Introduces restrictions
to the route. Valid values are specified in the
Restrictions section of this document. Only one
restriction can be specified.

units — Specifies the unit system
to use when expressing distance as text. See the
Unit Systems section of this document for more
information.

arrival_time — Specifies the desired time of arrival
for transit requests, in seconds since midnight, January 1, 1970 UTC. You
can specify either departure_time or arrival_time,
but not both. Note that arrival_time must be specified as an
integer.

departure_time — The desired time of departure. You
can specify the time as an integer in seconds since midnight, January 1,
1970 UTC. Alternatively, you can specify a value of now, which
sets the departure time to the current time (correct to the nearest second).
The departure time may be specified in two cases:

For requests where the travel mode is transit: You can optionally
specify one of departure_time or
arrival_time. If neither time is specified, the
departure_time defaults to now (that is, the departure
time defaults to the current time).

For requests where the travel mode is driving: You can specify the
departure_time to receive a route and trip duration
(response field: duration_in_traffic) that
take traffic conditions into account. This option is only available if
the request contains a valid API key, or a valid
Google Maps APIs Premium Plan client ID and signature. The
departure_time must be set to the current time or some time
in the future. It cannot be in the past.

Note: Distance Matrix
requests specifying departure_time when mode=driving
are limited to a maximum of 100
elements per request. The number of origins times the number of
destinations defines the number of elements.

traffic_model (defaults to
best_guess) —
Specifies the assumptions to use when calculating time in traffic. This
setting affects the value returned in the duration_in_traffic
field in the response, which contains the predicted time in traffic based on
historical averages. The traffic_model parameter may only be
specified for requests where the travel mode is driving, and
where the request includes a departure_time, and only if the
request includes an API key or a Google Maps APIs Premium Plan client ID.
The available values for this parameter are:

best_guess (default) indicates that the returned
duration_in_traffic should be the best estimate of travel
time given what is known about both historical traffic conditions and
live traffic. Live traffic becomes more important the closer the
departure_time is to now.

pessimistic indicates that the returned
duration_in_traffic should be longer than the actual travel
time on most days, though occasional days with particularly bad traffic
conditions may exceed this value.

optimistic indicates that the returned
duration_in_traffic should be shorter than the actual
travel time on most days, though occasional days with particularly good
traffic conditions may be faster than this value.

transit_mode — Specifies one or more preferred modes of
transit. This parameter may only be specified for requests where the
mode is transit. The parameter supports the
following arguments:

bus indicates that the calculated route should prefer
travel by bus.

subway indicates that the calculated route should prefer
travel by subway.

train indicates that the calculated route should prefer
travel by train.

tram indicates that the calculated route should prefer
travel by tram and light rail.

rail indicates that the calculated route should prefer
travel by train, tram, light rail, and subway. This is equivalent to
transit_mode=train|tram|subway.

transit_routing_preference — Specifies preferences for
transit requests. Using this parameter, you can bias the options returned,
rather than accepting the default best route chosen by the API.
This parameter may only be specified for requests where the
mode is transit. The parameter supports the
following arguments:

less_walking indicates that the calculated route should
prefer limited amounts of walking.

fewer_transfers indicates that the calculated route
should prefer a limited number of transfers.

Travel Modes

For the calculation of distances, you may specify the transportation mode to use.
By default, distances are calculated for driving mode. The following travel modes are
supported:

transit requests distance calculation via public transit
routes (where available). This value may only be specified if
the request includes an API key or a Google Maps APIs Premium Plan
client ID. If you set the mode to transit you can optionally
specify either a departure_time or an
arrival_time. If neither time is specified, the
departure_time defaults to now (that is, the departure time
defaults to the current time). You can also optionally include a
transit_mode and/or a
transit_routing_preference.

* Note: Both walking and
bicycling routes may sometimes not include clear pedestrian or
bicycling paths, so these responses will return warnings
in the returned result which you must display to the user.

Traffic Information

Traffic information is used when all the following apply (these are the conditions
required to receive the duration_in_traffic field in the Distance Matrix response):

The
travel mode parameter is driving, or is not specified
(driving is the default travel mode).

The request includes a valid
departure_time parameter. The departure_time can be set
to the current time or some time in the future. It cannot be in the past.

Optionally, you can include the
traffic_model
parameter in your request to specify the assumptions to use when calculating time in traffic.

The following URL initiates a Distance Matrix request for driving distances between Boston, MA
or Charlestown, MA, and Lexington, MA and Concord, MA. The request includes a departure time,
meeting all the requirements to return the duration_in_traffic field in the
Distance Matrix response.

Restrictions

Distances may be calculated that adhere to certain restrictions.
Restrictions are indicated by use of the avoid parameter, and
an argument to that parameter indicating the restriction to avoid. The
following restrictions are supported:

avoid=tolls

avoid=highways

avoid=ferries

avoid=indoor

* Note: the addition of
restrictions does not preclude routes that include the restricted feature;
it simply biases the result to more favorable routes.

Unit Systems

Distance Matrix results contain text within
distance fields to indicate the distance of the calculated
route. The unit system to use can be specified:

units=metric (default) returns distances in kilometers and
meters.

units=imperial returns distances in miles and feet.

* Note: this unit system
setting only affects the text displayed within
distance fields. The distance fields also contain
values which are always expressed in meters.

Distance Matrix Responses

Responses to Distance Matrix API queries are returned in the format
indicated by the output flag within the URL request's path.

Two sample HTTP requests are shown below, requesting distance and duration
from Vancouver, BC, Canada and from Seattle, WA, USA, to San Francisco, CA,
USA and to Victoria, BC, Canada.

We recommend that you use json as the preferred output flag
unless your service requires xml for some reason. Processing
XML trees requires some care, so that you reference proper nodes and
elements. See
Parsing XML with XPath for some recommended design patterns for output processing.

The remainder of this documentation will use JSON syntax.

Distance Matrix Response Elements

origin_addresses contains an array of addresses as
returned by the API from your original request. These are formatted
by the geocoder and
localized according to the language parameter passed with the
request.

destination_addresses contains an array of addresses as
returned by the API from your original request. As with
origin_addresses, these are localized if appropriate.

rows contains an array of elements, which
in turn each contain a status, duration, and
distance element.

Status Codes

The status fields within the response object contain the
status of the request, and may contain useful debugging information. The
Distance Matrix API returns a top-level status field, with information
about the request in general, as well as a status field for each element
field, with information about that particular origin-destination pairing.

Top-level Status Codes

OK indicates the response contains a
valid result.

INVALID_REQUEST indicates that the
provided request was invalid.

MAX_ELEMENTS_EXCEEDED indicates that the product of origins
and destinations exceeds the per-query
limit.

OVER_DAILY_LIMIT indicates any of the following:

The API key is missing or invalid.

Billing has not been enabled on your account.

A self-imposed usage cap has been exceeded.

The provided method of payment is no longer valid (for example, a
credit card has expired).

OVER_QUERY_LIMIT indicates the service has
received too many requests from your application within the allowed
time period.

REQUEST_DENIED indicates that the service denied
use of the Distance Matrix service by your application.

UNKNOWN_ERROR indicates a Distance Matrix request
could not be processed due to a server error. The request may
succeed if you try again.

Element-level Status Codes

OK indicates the response contains a
valid result.

NOT_FOUND indicates that the origin and/or destination of
this pairing could not be geocoded.

ZERO_RESULTS indicates no route could be found
between the origin and destination.

MAX_ROUTE_LENGTH_EXCEEDED indicates the requested route is too long and
cannot be processed.

Error Messages

When the top-level status code is other than OK, there may be an additional
error_message field within the Distance Matrix response object. This field contains
more detailed information about the reasons behind the given status code.

Note: This field is not guaranteed to be always present, and its
content is subject to change.

Rows

When the Distance Matrix API returns results, it places them within a JSON
rows array. Even if no results are returned (such as when the
origins and/or destinations don't exist), it still returns an empty array.
XML responses consist of zero or more <row> elements.

Rows are ordered according to the values in the origin
parameter of the request. Each row corresponds to an origin, and each
element within that row corresponds to a pairing of the
origin with a destination value.

Each row array contains one or more element
entries, which in turn contain the information about a single
origin-destination pairing.

Elements

The information about each origin-destination pairing is returned in an
element entry. An element contains the following
fields:

duration: The length of time it takes to travel this route,
expressed in seconds (the value field) and as
text. The textual representation is localized according to the
query's language parameter.

duration_in_traffic: The length of time it
takes to travel this route, based on current and historical traffic conditions. See the
traffic_model request parameter for the options you can use to
request that the returned value is optimistic, pessimistic, or a best-guess
estimate. The duration is expressed in seconds (the value
field) and as text. The textual representation is localized
according to the query's language parameter. The duration in
traffic is returned only if all of the following are true:

The request includes a departure_time parameter.

The request includes a valid API key, or a valid
Google Maps APIs Premium Plan client ID and signature.

Traffic conditions are available for the requested route.

The mode parameter is set to driving.

distance: The total distance of this route, expressed in
meters (value) and as text. The textual value
uses the unit system specified with the unit parameter of the
original request, or the origin's region.

fare: If present, contains the total fare (that is, the total
ticket costs) on this route. This property is only returned for transit
requests and only for transit providers where fare information is available.
The information includes: