Introduction

The Mapbox web services? APIs allow for programmatic access to Mapbox tools and services. Use these APIs to retrieve information about your account, upload and change resources, and use core Mapbox tools, like geocoding and directions.

This documentation provides examples of four different techniques for accessing Mapbox web services APIs:

• cURL
• Mapbox CLI
• Mapbox JavaScript SDK
• Mapbox Python SDK

Each library's documentation provides information on installing the library and how to use it.

This is REST API documentation: it's the most technical level of documentation for Mapbox's web services. If you're looking to use a map in an application, you probably want to use a library like Mapbox GL JS or Mapbox Mobile instead.

Reading this Documentation

This documentation is structured by API, which is a group of related functionality like Geocoding or Uploads, and then by endpoint, which is a specific method within that API that performs one action and is located at a specific URL.

Each endpoint in this documentation is described using several parts:

• The HTTP method: includes GET, POST, PUT, PATCH, DELETE
• The path: for instance, /geocoding/v5/{mode}/{query}.json
• URL parameters: these are the parts of the endpoint path wrapped in brackets, like {mode} in this example.
• Query parameters: contained in a table with an Option header, these are added to the query string part of the request.
• A token scope, if one is required.

All URLs referenced in the documentation have the base path https://api.mapbox.com. This base path goes before the endpoint path. In this example, you'd combine https://api.mapbox.com and /geocoding/v5/{mode}/{query}.json to get the request URL https://api.mapbox.com/geocoding/v5/{mode}/{query}.json.

For this endpoint, {mode} and {query} are the URL parameters. In a request, you replace their placeholders with real values: for instance, you'd choose mapbox.places as your mode and Chester as your query, and get the URL https://api.mapbox.com/geocoding/v5/mapbox.places/Chester.json

Query parameters are added to the end of the URL with query string encoding. If you wanted to add the country query parameter to that Geocoding request, you'd the query string ?country=us to the end of the URL, producing https://api.mapbox.com/geocoding/v5/mapbox.places/Chester.json?country=us.

All endpoints require an access token?, which is provided as a query parameter. So the final geocoding request you would construct would look like https://api.mapbox.com/geocoding/v5/mapbox.places/Chester.json?country=us&access_token=pk.my-token-value The next section covers how you get and use access tokens.

Access tokens

Access to Mapbox web services? requires an access token that connects API requests to your account. The example requests in this documentation don't include an access token?: you will need to supply one using the access_token query option or by specifying the token in the SDK? or library.

Your default access token is available on the right side of your Mapbox Studio home page. You can also manage and create additional tokens on your API access tokens page in Mapbox Studio?.

When creating a new access token, you have the option of adding one or more scopes. Each scope adds a different permission to the token, allowing it to be used to access restricted APIs. Throughout the documentation, we specify the scope required to access each endpoint.

Versioning

Each Mapbox API is versioned with a version string specified in the base URL that can be incremented independently from other APIs.

The Maps API and Directions API are the exceptions: their endpoints are prefixed with /v4/{map_id} and /v4/directions instead of putting the version after the API name. This mismatch will be fixed in the next API version.

Using the newest available API is always encouraged.

These changes are considered backwards compatible and will not require the version string to be incremented:

• Adding properties to JSON objects.
• Changing the number of items returned in a single listing request.
• Changing rate limiting thresholds.
• The structure or length of identifiers generated by the API.
• Changing error messages.

These changes are considered backwards incompatible and will require the version string to be incremented:

• Removing properties from JSON objects.
• Changing an API's URL structure

In the event that certain functionality is deprecated, we will give at least 90 days notice via email. You will only receive a deprecation email if we detect you are using part of the API that is being deprecated.

Rate limits

Mapbox APIs have rate limits that cap the number of requests that can be made against an endpoint. If you exceed a rate limit, your request will be throttled and you will receive HTTP 429 Too Many Requests responses from the API.

CORS

Mapbox web services? support Cross-Origin Requests with no domain restrictions. To support Internet Explorer 8 and 9, use a library that falls back to XDomainRequest, like corslite.

Retina

Mapbox supports Retina image output on all APIs that serve images. Add @2x before the file extension on a URL to request an image at double scale. For instance, a map tile that is 256×256 pixels will be 512×512 pixels with @2x, but show the same content. When displayed on a page, the image will be still sized to 256×256 pixels, but 4 pixels of the original will represent 1 pixel in screen units.

The @2x part of the URL goes before the entire format, so a URL that ends in .png would end with @2x.png as a Retina image.

The only assets that are not available at Retina scale are tilesets uploaded from TileMill? or as MBTiles?.

HTTPS

We recommend all access to Mapbox is over HTTPS. Except for the Maps API, requests initiated over HTTP are automatically upgraded to HTTPS.

Pagination

Pagination lets you list many objects from an API by using more than one request. After receiving a page of objects, the next page can be requested using the next link relation in Link header of the response. This process can be repeated until the server sends a response without a Link header or without a next link relation, which signals the end of the collection.

Your application must use the Link header for pagination instead of constructing your own URLs as the specific URLs used for pagination may change at any time. The Python requests library, and the link-header-parser module for JavaScript can parse Link headers. Link headers follow the RFC 5988 specifications.

Pagination is supported on the Datasets, Uploads, and Styles list endpoints.

Dates

Most dates and times returned by the API are represented in RFC 3339 format, which can be parsed by the JavaScript Date constructor, the Python arrow library, and many other libraries and languages.

The only exception to this rule is the Retrieve TileJSON metadata endpoint that returns created and modified properties as Unix time.

Uploads

The Mapbox Uploads API transforms geographic data into tilesets that can be used with maps and geographic applications. Given a wide variety of geospatial formats, it normalizes projections and generates tiles at multiple zoom levels to make data viewable on the web.

The upload workflow begins with a file and ends with a tileset?, or if you have invalid data, an error.

1. Retrieve S3 credentials to stage the file
2. Use an S3 client, like the AWS SDK, to upload a file to S3 using those credentials
3. Create an upload using the staged file's URL
4. Retrieve the upload's status as it is processed into a tileset
5. Once the upload is complete, use the tileset ID like you'd use any other tileset

Limits

Retrieve S3 credentials

Mapbox provides an Amazon S3 bucket to stage your file while your upload is processed. Uploads must be staged in this bucket before being uploaded to your Mapbox account. You can retrieve temporary credentials from this endpoint.

The response body is a JSON object containing the following properties.

Use these credentials to store your data in the provided bucket with the provided key using the AWS CLI or AWS SDK? of your choice. The bucket is located in AWS region us-east-1.

Create an upload

Once you've used the temporary S3 credentials to transfer your file to Mapbox's staging bucket, you can trigger the generation of a tileset? given the file's URL and a destination tileset ID.

The request body is a JSON object containing the following properties.

Reuse of a tileset value will replace existing data: use a random value to make sure that a new tileset is created, or check existing tilesets first.

The response body is a JSON object containing the following properties.

Retrieve upload status

Upload processing is fast but not immediate. Once an upload is created, you can track its status. Uploads have a progress property that will start at 0 and end at 1 when an upload is complete. If there's an error processing an upload, the error property will include an error message.

Retrieve recent upload statuses

You can retrieve multiple upload statuses at the same time, sorted by the most recently created. This request returns the same information as individual upload status, but for all recent uploads. The list is limited to 1MB of JSON.

This endpoint supports pagination so that you can list many uploads. Up to 100 items can be requested at a time using the limit parameter. It also supports another parameter, reverse:

Remove an upload

Remove a completed upload status from the upload listing.

Uploads are only statuses: removing an upload from the listing doesn't delete the associated tileset?. Tilesets can only be deleted from within Mapbox Studio?. An upload cannot be removed until it is completed.

Styles

The Mapbox Styles API lets you read and change map styles, fonts, and icons. This API is the basis for Mapbox Studio, our cartography software.

If you use Studio, Mapbox GL JS or the Mapbox Mobile SDKs, you're already using the Styles API. This documentation is geared toward software developers who want to programmatically read & write these resources: it isn't necessary to read or understand this reference to design or use maps.

You'll want to be familiar with the Mapbox GL Style Spec to use this API: it defines the structure of map styles and is the open standard that helps Studio communicate with APIs and produce maps compatible with our libraries (like GL JS and Mobile). When we refer to style objects, they are objects that fit the Mapbox GL? Style Spec. You can see examples of these styles in our mapbox-gl-styles project, or you can create a new style? using Mapbox Studio.

Limits

• Styles cannot reference more than 15 sources.
• Styles cannot be larger than 5MB. This limit only applies to the style document itself, not the sprites, fonts, tilesets, or other resources it references.
• The number of styles allowed per account varies based on plan level.

Mapbox styles

The following styles are available to all accounts using a valid access token?:

• mapbox://styles/mapbox/streets-v8
• mapbox://styles/mapbox/light-v8
• mapbox://styles/mapbox/dark-v8
• mapbox://styles/mapbox/emerald-v8
• mapbox://styles/mapbox/basic-v8
• mapbox://styles/mapbox/bright-v8
• mapbox://styles/mapbox/satellite-v8
• mapbox://styles/mapbox/satellite-hybrid-v8

The style object

The style object conforms to the Mapbox GL Style Specification, with these additional account-related properties:

Retrieve a style

Retrieve a style? as a JSON document. The returned style object will be in the Mapbox GL Style Spec format.

List styles

Retrieve a list of styles for an account. This endpoint does not return full styles, but returns style? metadata.

Create a style

Creates a style? in your account. The posted style object must be both valid JSON and aligned to the Mapbox GL Style Spec: invalid styles will produce a descriptive validation error.

Only the most recent version of the Mapbox GL? Style Spec is supported. If the optional "name" property is omitted, it will be automatically set to the style's ID.

The style you get back from the API will have new properties that the server has added: created, id, modified, owner, and draft.

Update a style

Updates an existing style? in your account with new content.

Requesting a style and then using the same content to update the style will fail: you'll need to remove the created and modified properties before updating a style. The name property, which is optional for style creation, is required when updating a style. Cross-version PATCH requests are rejected.

Delete a style

Deletes a style?. All sprites that belong to this style will also be deleted and the style will no longer be available.

Fonts

Two types of fonts are supported: TrueType fonts, usually with .ttf file extensions, and OpenType fonts, with .otf extensions. The API accepts fonts as raw binary data, allows those fonts to be deleted, and generates encoded letters for map renderers.

Fonts are managed on a per-account basis: styles can use any font from the same account.

Font limits

• Fonts must be smaller than 30MB.
• Accounts are limited to 100 fonts.

Retrieve font glyph ranges

Glyph ranges are usually not of interest unless you're building a map renderer, but this is the endpoint where you can access them.

Font glyph ranges are protocol buffer-encoded signed distance fields. They can be used to show fonts at a variety of scales and rotations. One glyph is used at all scales.

Sprites

Sprites are the way that Mapbox GL JS? and Mapbox Mobile efficiently request and show icons. They are collections of icons that can be used in styles as markers or patterns in symbol layers. Icons are SVG? images that can be added and removed at will. The Styles API automatically collects these SVG images and renders them into a single PNG image and a JSON document that describes where each icon is positioned.

The sprite? JSON document is specified as part of the the Mapbox GL Style Spec.

Sprites are managed on a per-style basis: each sprite belongs to a style, so the sprite limit of 100 icons is also a per-style limit. All sprite-related API methods will require a {style_id} parameter referring to the style? that sprite belongs to.

Sprite limits

• Each icon must be smaller than 400kB.
• Mapbox supports most, but not all SVG properties. Our SVG troubleshooting document describes these limits.
• Icons can be up to 512px in each dimension.
• Sprites can contain up to 100 icons.

Retrieve a sprite image or JSON

Retrieves a sprite? image or JSON document.

Add new icon to sprite

Adds a new icon to an existing sprite?.

The request body should be raw SVG? data.

Delete icon from sprite

Deletes an icon from an existing sprite?.

Embed a style

Request embeddable HTML suitable for fullscreen map displays or for inserting into blog posts and articles as <iframe> content.

Maps

The Mapbox Maps API supports reading raster tilesets, vector tilesets, and Mapbox Editor? project features. Tilesets can be retrieved as images, TileJSON, or HTML slippy maps for embedding. Mapbox Editor project features can be retrieved as GeoJSON? or KML?.

If you use Mapbox.js, Mapbox GL JS, or another library like Leaflet, you're already using this API. This documentation is geared toward software developers who want to programmatically read these resources: it isn't necessary to read or understand this reference to design or use maps.

Mapbox classic map IDs

The following map IDs are accessible to all accounts using a valid access token?:

• mapbox.streets
• mapbox.light
• mapbox.dark
• mapbox.satellite
• mapbox.streets-satellite
• mapbox.wheatpaste
• mapbox.streets-basic
• mapbox.comic
• mapbox.outdoors
• mapbox.run-bike-hike
• mapbox.pencil
• mapbox.pirates
• mapbox.emerald
• mapbox.high-contrast

Retrieve tiles

Returns a image tile, vector tile, or UTFGrid in the specified format.

The {z}/{x}/{y} parameters are the tile coordinates as described in the Slippy Map Tilenames specification: they specify the tile's zoom level {z} and column {x} and row {y}.

The format of any image request can be replaced by any of the following formats to adjust image quality for different bandwidth requirements. Higher-compression formats like jpg70 or png32 can be useful to favor performance over image quality.

You can prefix the format with @2x to request a high DPI version. The @2x is placed after the {z}/{x}/{y} and before the ., like 1/0/[email protected]

The response is an image tile in the specified format. For performance, image tiles are delivered with a max-age header value set 12 hours in the future.

Retrieve an HTML slippy map

Returns an HTML slippy map for sharing or embedding.

The response is HTML of a slippy map.

Retrieve features from Mapbox Editor projects

Retrieve vector features from Mapbox Editor? projects as GeoJSON? or KML?. GeoJSON returns a FeatureCollection with features that conform to the simplestyle-spec.

Retrieve features from vector tiles

Retrieve data about specific vector features at a specified location within a vector tileset?. The response body is a GeoJSON? FeatureCollection of features at or near the geographic point described by {lon},{lat} and within the distance described by the radius parameter. The geometry of the feature is not returned.

The radius parameter has no upper bound and is required for queries against point and line data. Due to the nature of tile buffering, a query with a large radius made against equally large point or line data may not include all possible features in the results.

Restrictions and limits

Use of this endpoint is rate limited to 600 requests per minute. For a higher rate limit, contact us.

Exceeding the limits above will result in an HTTP 429 response. For information on rate limit headers, see Rate limits.

The original geometry of the result features will not be returned in the resultset. The geometry type in the response will be Point for all features returned in the FeatureCollection:

• For Polygon and MultiPolygon features the geometry is the point at the queried lon,lat
• For LineString and MultiLineString features the geometry is the nearest point on the feature within the radius threshold of lon,lat
• For Point and MultiPoint features the geometry is the nearest point within the radius threshold of lon,lat

Features in the response body will include a tilequery object with the following additional properties:

Retrieve TileJSON metadata

Returns TileJSON metadata for a tileset?. This is an object that describes a map's resources, like tiles, markers, and UTFGrid, as well as its name, description, and centerpoint.

Static

The Mapbox Static API returns static maps and raster tiles from styles in the Mapbox GL Style Spec.

Static maps are standalone images that can be displayed on web and mobile devices without the aid of a mapping library or API. They look like an embedded map without interactivity or controls.

Raster tiles can be used in traditional web mapping libraries like Mapbox.js, Leaflet, OpenLayers, and others.

Retrieve a static map from a style

In contrast to the legacy Static API, this API supports pitch, bearing, and decimal zoom levels.

The position of the map is represented by 5 numbers: longitude, latitude, zoom, bearing, and pitch. The last two numbers, bearing and pitch, are optional: if you only specify bearing and not pitch, pitch will default to 0. If you specify neither, they will both default to 0.

Retrieve raster tiles from styles

Request 512x512 image tiles from a style? that can be arranged and displayed with the help of a mapping library. Normally, you will not need to interact with this API directly, as our SDKs handle this for you.

Note that these image tiles will be offset by 1 zoom level when compared to traditional 256x256 tiles (for example, 512x512 tiles at zoom level 4 are equivalent to traditional tiles at zoom level 5). Tiles are 512px by 512px unless the @2x parameter is included, in which case they're scaled to 1024px by 1024px.

Static (Classic)

The classic Mapbox Static API lets you request static maps from tilesets, with the option to add vector data as overlays. Static maps are standalone images that can be displayed on web and mobile devices without the aid of a mapping library or API. They look like an embedded map without any interactivity or controls.

If you've uploaded data to Mapbox, you've already seen the classic Static API in action, powering the images at the top of all tileset? detail pages.

Limits

• The maximum size for a static map image is 1280x1280 pixels.

• The URL for a request to this API cannot be longer than 4096 characters.

• Overlays cannot consist of more than 100 features.

• Markers must be less 8192 pixels.

• Static map images give you design flexibility in how you want to display map attribution. When using Static maps it is your responsibility to add proper attribution for maps in your website or application.

Retrieve a static map image

The support formats are the same as for the Mapbox Maps API:

The {overlay} parameter can specify one or more features to draw on top of the map. The list of features should be comma-separated. Each overlay feature can be in one of three formats: marker, geojson or path.

Marker

{name}-{label}+{color}({lon},{lat})

Custom marker

url-{url}({lon},{lat})

Custom markers are cached according to the Expires and Cache-Control headers. Make sure that at least one of these headers is set to an proper value to prevent repeated requests for the custom marker image.

The marker image is always centered on the specified location. When creating an asymmetric marker like a pin, make sure that the tip of the pin is at the center of the image.

GeoJSON

geojson({geojson})

The {geojson} argument must be a valid GeoJSON object. simplestyle-spec styles for GeoJSON? features will be respected and rendered.

GeoJSON features will be respected and rendered.

Path

path-{strokecolor}-{strokeopacity}+{fillcolor}-{fillopacity}({polyline})

Encoded polylines can be used with the Static API via the path parameter.

Retrieve a standalone marker

Request a single marker image without any background map.

Directions

The Mapbox Directions API will show you how to get where you're going. Routing is fundamental to business logistics and consumer applications. With the Directions API, you can:

• calculate optimal driving, walking, and cycling routes
• produce turn-by-turn directions
• produce routes with up to 25 waypoints anywhere on earth

This API supports three different routing profiles:

• mapbox.driving for car and motorcycle routing. This profile shows the fastest routes by preferring high-speed roads like highways.
• mapbox.walking for pedestrian and hiking routing. This profile shows the shortest path by using sidewalks and trails.
• mapbox.cycling for bicycle routing. This profile shows routes that are short and safer for cyclist, avoiding highways and preferring streets with bike lanes.

Retrieve directions

Retrieve directions between waypoints. This can include both the route's geometry and instructions for each turn.

Polylines are encoded with a precision level of 6: be sure to configure your decoding library to use 6 precision. Polyline decoding libraries exist for JavaScript, Swift, Ruby, and many other languages.

The response to a directions request is a JSON object with the following properties:

• origin: a GeoJSON Feature with a Point geometry type representing the starting point of the route. Must have a name property, but more properties are also acceptable.
• destination: as above, but representing the final destination of the route.
• waypoints: an array of GeoJSON Feature Objects, as above, representing intermediate waypoints.

• routes: an array containing the recommended (fastest) route and, at most, one alternative route. Each element is a JSON object with the following properties:

  • distance: the distance of the route in meters
  • duration: the estimated travel time in seconds
  • summary: a short, human-readable summary of of the route
  • geometry: the geometry of the route as either a GeoJSON LineString or encoded polyline with precision 6

  • steps: an array of route steps -- maneuvers like turns or merges followed by a distance of travel to the next step. Each element is a JSON object with the following properties:

    • distance: the distance to the next maneuver in meters
    • duration: the estimated travel time to the next maneuver in seconds
    • way_name: the road or path the maneuver is on
    • direction: the rough cardinal direction of travel following the maneuver ('N', 'NE', 'E', 'SE', 'S', 'SW', 'W', or 'NW')
    • heading: the clockwise angle from true north to the direction of travel following the maneuver

    • maneuver: a JSON object representing the maneuver with the following properties:

      • type: the type of maneuver; one of: continue, bear right, turn right, sharp right, u-turn, sharp left, turn left, bear left, waypoint, depart, enter roundabout, and arrive. New maneuver types may be introduced in the future without an API version change.
      • location: a GeoJSON Point geometry where the maneuver is located.
      • instruction: human-readable text or HTML describing the maneuver. See the instructions parameter above.

      • mode: the mode of transportation. Possible values as follows:

        • For driving: driving, ferry, movable bridge, unaccessible
        • For walking: walking, ferry, unaccessible
        • For cycling: cycling, walking, ferry, train, moveable bridge, unaccessible

Map Matching

The Mapbox Map Matching API snaps fuzzy, inaccurate traces from a GPS unit or a phone to the OpenStreetMap? road and path network using the Directions API. This produces clean paths that can be displayed on a map or used for other analysis.

Limits

• Maximum 60 requests per minute
• Maximum 100 coordinates per request
• Results must be displayed on a Mapbox map using one of our libraries or SDKs

For high volume or other use cases, contact us.

Retrieve a match

Returns a path on the road and path network closest to the input traces.

Request body must be one GeoJSON Feature with a LineString geometry. The LineString may have up to 100 positions.

If your traces are in GPX or KML format, you can use toGeoJSON to transform them to GeoJSON?.

It is recommended to include timestamps, since they help improve the quality of the matching. The timestamps must be ascending. For best results, your timestamps should have a sample rate of about 5 seconds.

Some pre-processing tips to achieve the best results:

• The Map Matching API is limited to processing traces with up to 100 coordinates. If you need to process longer traces, you can split the trace and make multiple requests.
• Clusters of points (like a person waiting at a train crossing for a few minutes) often don't add more information to a trace and should be removed.
• Map matching works best with a sample rate of 5 seconds between points. If your trace has a higher sample rate, you may want to downsample your trace.
• geojson-tidy removes clusters and re-samples traces, which can be useful for preprocessing.

The response is a GeoJSON FeatureCollection aligned with the OpenStreetMap? road/path network. It may include one or more GeoJSON Features; on clean matches, only one feature is returned, but when the matching algorithm cannot decide the correct match between two points, it will omit that line and create several sub-matches, each as a feature. The higher the number of features, the more likely that the input traces are poorly aligned to the road network.

All routing responses will include a code property that describes the type of result. If a server error occurs, the HTTP status code will be 500 or higher and the response will not include a code property.

Geocoding

The Mapbox Geocoding API does two things: geocoding and reverse geocoding.

Geocoding lets you convert location text into geographic coordinates: turning 1600 Pennsylvania Ave NW into -77.0366, 38.8971.

Reverse geocoding turns geographic coordinates into place names: from -77.036, 38.897 to 1600 Pennsylvania Ave NW. These place names can vary from specific addresses to states and countries that contain the given coordinate.

Restrictions and limits

Use of the geocoding API is rate limited by access token?. These limits vary by plan.

Exceeding the limits above will result in an HTTP 429 response. For information on rate limit headers, see Rate limits.

Batch geocoding is only available with an Enterprise plan. On all other plan levels, one geocode is permitted per request.

The results from geocoding with the mapbox.places mode must be displayed on a Mapbox map and cannot be stored permanently. The mapbox.places-permanent mode, available with an Enterprise plan, does not have these licensing restrictions.

The Mapbox Geocoding API coverage map lists the types of geocoding results support in each area of the world.

Request format

The {country} parameter limits results to a set of one or more countries, specified with ISO 3166 alpha 2 country codes and separated by commas.

The {proximity} parameter biases search results around a specific location given in {longitude},{latitude} coordinates. Results will not be filtered by location or ordered by distance, but location will be considered along with textual relevance and other criteria when scoring and sorting results.

The {autocomplete} parameter controls whether autocomplete results are included. Autocomplete results can partially match the query: for example, searching for washingto could include washington even though only the prefix matches. Autocomplete is useful for offering fast type-ahead or autocomplete results in user interfaces. If your queries represent complete addresses or place names, you can disable this behavior and exclude partial matches by setting the {autocomplete} parameter to false.

Response format

Our geocoding data is updated and improved constantly and responses for a given query may change. Geocoding results are returned in Carmen GeoJSON format. This format declares the types and existence of properties, but not their specific values: their values can change as our data improves.

Feature IDs are formatted like {type}.{id}. {type} is one of the types listed above. Additional feature types may be added in the future, but the current types will stay the same. The numeric part of a feature ID may change between data updates.

The {properties} property of the feature is unstable: only what is specified in Carmen GeoJSON is part of the stable API.

Results are returned in order of relevance. They also have a relevance property that is based on how much of the query matched text in the result. You can use the relevance property to remove rough results if you require a response that matches your whole query.

Search for places

Try this in API Playground

This is often called forward geocoding. Request feature data that best matches the input {query} text. The response includes one or more results ordered by relevance.

This API is used by the Mapbox.js L.mapbox.geocoderControl and the mapbox-gl-geocoder user interfaces.

Retrieve places near a location

Try this in API Playground

This is often called reverse geocoding. Request feature data located at the input {longitude},{latitude} coordinates. The response includes at most one result from each type.

Batch requests

This feature is only available with the mapbox.places-permanent mode

Batch requests have the same parameters as normal requests, but can include more than one query by separating queries with the ; character. Each query should be URL encoded, but the ; character should not be encoded: it should be included verbatim.

With the mapbox.places-permanent mode, you can do up to 50 forward or reverse geocoding queries in a single request. The response is an array of individual geocoder responses formatted the same as individual results. Each query in a batch request counts individually against your account's rate limits.