Mapbox MCP Server
OfficialSummary: This Mapbox MCP server gives AI agents geospatial intelligence through Mapbox APIs and offline geospatial calculations.
Search & geocode: Convert addresses/places to coordinates and back, search POIs/categories/brands, retrieve place details, and ground coordinates with nearby POIs and reachability.
Routing & analysis: Get directions, travel-time matrices, optimized multi-stop routes, map-matched GPS traces, and isochrone reachability areas.
Maps: Generate static map images with markers, paths, polygons, and GeoJSON overlays; directions can include interactive MCP map UI metadata where supported.
Offline calculations: Compute distance, bearing, midpoint, destination, length, area, bounding box, centroid, buffer, simplification, convex hull, nearest points, point-in-polygon tests, and polygon union/intersection/difference without API calls.
Travel profiles: Support driving, driving-traffic, walking, and cycling across routing, matrix, isochrone, optimization, and map-matching tools.
Provides access to Mapbox's geospatial services including geocoding, points of interest search, multi-modal routing, travel time matrices, route optimization, map matching, isochrone generation, static map images, and offline geospatial calculations.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Mapbox MCP Server Find coffee shops near the Empire State Building"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Mapbox MCP Server
Node.js server implementing Model Context Protocol (MCP) for Mapbox APIs.
Unlock Geospatial Intelligence for Your AI Applications
The Mapbox MCP Server transforms any AI agent or application into a geospatially-aware system by providing seamless access to Mapbox's comprehensive location intelligence platform. With this server, your AI can understand and reason about places, navigate the physical world, and access rich geospatial data including:
Global geocoding to convert addresses and place names to coordinates and vice versa
Points of interest (POI) search across millions of businesses, landmarks, and places worldwide
Multi-modal routing for driving, walking, and cycling with real-time traffic
Travel time matrices to analyze accessibility and optimize logistics
Route optimization to find the optimal visiting order for multiple stops (traveling salesman problem)
Map matching to snap GPS traces to the road network for clean route visualization
Isochrone generation to visualize areas reachable within specific time or distance constraints
Live, interactive map rendering (
render_map_tool) to display routes, search results, and your own custom GeoJSON on a real Mapbox GL JS map directly inside the chatStatic map images to create visual representations of locations, routes, and geographic data
Offline geospatial calculations for distance, area, bearing, buffers, and spatial analysis without requiring API calls
Whether you're building an AI travel assistant, logistics optimizer, location-based recommender, or any application that needs to understand "where", the Mapbox MCP Server provides the spatial intelligence to make it possible. You can also enable it on popular clients like Claude Desktop and VS Code. See below for details

Usage
A Mapbox access token is required to use this MCP server.
Related MCP server: Mapbox MCP Server
Hosted MCP Endpoint
For quick access, you can use our hosted MCP endpoint:
Endpoint: https://mcp.mapbox.com/mcp
For detailed setup instructions for different clients and API usage, see the Hosted MCP Server Guide.
To get a Mapbox access token:
Sign up for a free Mapbox account at mapbox.com/signup
Navigate to your Account page
Create a new token or use the default public token
For more information about Mapbox access tokens, see the Mapbox documentation on access tokens.
Integration Guides
For detailed setup instructions for different integrations, refer to the following guides:
Claude Desktop Setup - Instructions for configuring Claude Desktop to work with this MCP server
Goose Setup - Setting up Goose AI agent framework
VS Code Setup - Setting up a development environment in Visual Studio Code
Cursor AI IDE Setup - Setting up a development environment in Cursor AI IDE
Smolagents Integration - Example showing how to connect Smolagents AI agents to Mapbox's tools
Importing Tools Directly - Use Mapbox tools in your own applications without running the MCP server
render_map_toolGuide - The map visualization primitive: full payload schema and how to render your own data standalone, without any other Mapbox toolElicitations - How
search_and_geocode_toolanddirections_toolask the user to disambiguate results or pick a route, and how they fall back gracefully when the client doesn't support it
Example Prompts
Try these prompts with Claude Desktop or other MCP clients after setup:
Location Grounding
For coordinate-first queries — "what's near me", "what neighborhood is this", "what's reachable in N minutes" — use ground_location_tool. It composes reverse geocoding, category search, and isochrone in a single call, adaptively choosing the right strategy based on the query, and returns typed records (names, addresses, coordinates, distances, reachability polygons) with citations.
Each of the four prompts below exercises a different strategy in one tool call:
Neighborhood — "What neighborhood is 47.6097, -122.3408, and what's around me?"
POI — "Coffee shops within a 10-minute walk of 40.7580, -73.9855"
Region — "What can I reach in a 15-minute walk from 37.7749, -122.4194?"
Routing — "Closest routable point to drop someone off at 34.0522, -118.2437"
Location Discovery
"Find coffee shops within walking distance of the Empire State Building"
"I want to go from Seattle to Portland, is there a Starbucks along the way?"
"Show me gas stations along the route from Boston to New York"
"What restaurants are near Times Square?"
Navigation & Travel
"Get driving directions from LAX to Hollywood with current traffic"
"How long would it take to walk from Central Park to Times Square?"
"How much climbing is on a bike ride from the Ferry Building to Twin Peaks?"
"Calculate travel time from my hotel (Four Seasons) to JFK Airport by taxi during rush hour"
Visualization & Maps
"Using the Mapbox map render tool, show me directions from the Golden Gate Bridge to Union Square in San Francisco" — renders a live, interactive route on a real Mapbox map
"Create a map image showing the route from Golden Gate Bridge to Fisherman's Wharf with markers at both locations"
"Show me a satellite view of Manhattan with key landmarks marked"
"Generate a map highlighting all Starbucks locations within a mile of downtown Seattle"
"Show a fill polygon over these coordinates: [...], with a marker labeled 'Warehouse' at [...]" — renders your own GeoJSON directly via
render_map_tool, no other Mapbox tool needed
Analysis & Planning
"Show me areas reachable within 30 minutes of downtown Portland by car"
"Calculate a travel time matrix between these 3 hotel locations (Marriott, Sheraton and Hilton) and the convention center in Denver"
"Find the optimal route visiting these 3 tourist attractions (Golden Gate, Musical Stairs and Fisherman's Wharf) in San Francisco"
"Optimize a delivery route for these 8 addresses: [list of addresses]"
GPS & Route Matching
"Clean up this GPS trace and show the actual route on roads: [list of coordinates with timestamps]"
"Snap this recorded bicycle ride to the cycling network: [GPS coordinates]"
"Match this driving route to the road network and show traffic congestion levels"
Offline Geospatial Calculations
"What's the distance in miles between these two coordinates?"
"Calculate the area of this polygon in square kilometers"
"Is the point at 37.7749°N, 122.4194°W inside this service area polygon?"
"What's the bearing from San Francisco to New York?"
"Find the midpoint between London and Paris"
"Create a 5-mile buffer zone around this location"
"Calculate the centroid of this neighborhood boundary"
"What's the bounding box for these route coordinates?"
"Simplify this complex polygon to reduce the number of points"
Tips for Better Results
Be specific about locations (use full addresses or landmark names)
Specify your preferred travel method (driving, walking, cycling)
Include time constraints when relevant ("during rush hour", "at 3 PM")
Ask for specific output formats when needed ("as a map image", "in JSON format")
Detailed examples: See examples/search-along-route.md for comprehensive examples of the search-along-route prompt with different use cases and MCP Inspector testing instructions.
Resources
The MCP server exposes static reference data as MCP resources. Resources provide read-only access to data that clients can reference directly without making tool calls.
Available Resources
Mapbox Categories Resource
URI Pattern: mapbox://categories or mapbox://categories/{language}
Access the complete list of available category IDs for use with the category search tool. Categories can be used to filter search results by type (e.g., "restaurant", "hotel", "gas_station").
Examples:
mapbox://categories- Default (English) category listmapbox://categories/ja- Japanese category namesmapbox://categories/es- Spanish category names
Accessing Resources:
Clients with native MCP resource support: Use the
resources/readMCP protocol methodClients without resource support: Use the
resource_reader_toolwith the resource URI
Rich Map Previews (render_map_tool)
Every geospatial tool in this server (directions, isochrone, search, and more) can display its result as a live, interactive Mapbox GL JS map via render_map_tool — the server's single visualization primitive. It renders through the MCP Apps protocol (@modelcontextprotocol/ext-apps) as a self-contained HTML panel directly inside the chat, with a Fullscreen toggle, in supported clients:
Claude Desktop ✅
VS Code with GitHub Copilot ✅
Claude Code ✅
Goose ✅
You don't need any of this server's other tools to use it. render_map_tool also accepts hand-composed GeoJSON directly — your own polygons, markers, and routes — with no dependency on directions_tool, isochrone_tool, or any other Mapbox API call. See the full render_map_tool guide for the payload schema and a complete standalone example.
If you need a guaranteed static image in clients without MCP Apps support, use static_map_image_tool instead — it returns a base64-encoded PNG/JPEG that every client can display.
A map next to the chat in ChatGPT
In ChatGPT, render_map_tool maps open as a tab next to the chat and stay open. You can also open an empty map from "+" → "More tools" → Mapbox Map. The map shares its view and the selected place (a pin, a search result, or a base map label such as a shop or a neighborhood) with the conversation, and in ChatGPT Desktop it registers WebMCP tools (redraw_map, search_map, add_places, move_map, read_map) so the model draws on the open map instead of opening another. On the web, a follow-up opens another map. Hosts without the OpenAI MCP Extensions ignore all of this.
CLIENT_NEEDS_RESOURCE_FALLBACK
Resource Fallback Tools (Opt-In for Non-Compliant Clients)
Resources are a core MCP feature supported by most clients (Claude Desktop, VS Code, MCP Inspector, etc.). However, some clients (like smolagents) don't support resources at all. For these clients, the server can provide "resource fallback tools" that deliver the same content as resources but via tool calls.
Fallback Tools:
resource_reader_tool- Generic fallback for reading any resource by URIcategory_list_tool- Provides access to category list (mapbox://categories)
By default, these tools are NOT included (assumes your client supports resources). If your client doesn't support resources, enable the fallback tools:
export CLIENT_NEEDS_RESOURCE_FALLBACK=trueWhen to set this:
✅ Set to
trueif using smolagents or other clients without resource support❌ Leave unset (default) if using Claude Desktop, VS Code, MCP Inspector, or any resource-capable client
❌ Leave unset if unsure (most clients support resources)
Tools
Utility Tools
Resource Reader Tool
Provides access to MCP resources for clients that don't support the native MCP resource API. Use this tool to read resources like the category list.
Parameters:
uri: The resource URI to read (e.g.,mapbox://categories,mapbox://categories/ja)
Example Usage:
Read default categories:
{"uri": "mapbox://categories"}Read Japanese categories:
{"uri": "mapbox://categories/ja"}
Note: If your MCP client supports native resources, prefer using the resource API directly for better performance.
Offline Geospatial Tools
These tools perform geospatial calculations completely offline without requiring Mapbox API calls. They use Turf.js for accurate geographic computations and work anywhere, even without internet connectivity.
Distance Tool
Calculate the distance between two geographic coordinates using the Haversine formula.
Features:
Supports multiple units: kilometers, miles, meters, feet, nautical miles
Accurate great-circle distance calculation
No API calls required
Example Usage: "What's the distance between San Francisco (37.7749°N, 122.4194°W) and New York (40.7128°N, 74.0060°W)?"
Points Within Polygon Tool
Test one or more points against a polygon or multipolygon, returning only those inside. Handles a single point or a batch in one call.
Features:
Works with complex polygons including holes
Supports multipolygons
Batch-tests any number of points in one call
Useful for geofencing, delivery zone validation, and customer segmentation
Example Usage: "Which of these delivery addresses are inside our service area?"
Destination Tool
Calculate a destination point given a starting point, bearing, and distance using geodesic (great-circle) offset.
Features:
Straight-line offset, not a routed path
Useful for "find a point 5km north of X" or constructing search offsets
No API calls required
Example Usage: "What's the point 10km northeast of the Space Needle?"
Bearing Tool
Calculate the compass direction (bearing) from one coordinate to another.
Features:
Returns bearing in degrees (0-360°)
Provides cardinal direction (N, NE, E, SE, S, SW, W, NW)
Useful for navigation and directional queries
Example Usage: "What direction should I head to go from here to the airport?"
Midpoint Tool
Find the geographic midpoint between two coordinates along the great circle path.
Features:
Calculates true midpoint on Earth's curved surface
Useful for meeting point suggestions
Handles long-distance calculations correctly
Example Usage: "What's halfway between San Francisco and New York?"
Centroid Tool
Calculate the geometric center (centroid) of a polygon or multipolygon.
Features:
Works with complex shapes
Returns arithmetic mean of all points
Useful for placing labels or markers
Example Usage: "Where should I place a marker for this neighborhood boundary?"
Area Tool
Calculate the area of a polygon.
Features:
Supports multiple units: square meters, square kilometers, acres, hectares, square miles, square feet
Accurate area calculation on Earth's surface
Works with polygons of any size
Example Usage: "What's the area of this park in acres?"
Bounding Box Tool
Calculate the minimum bounding box (bbox) that contains a geometry.
Features:
Works with points, lines, polygons, and multipolygons
Returns [minLongitude, minLatitude, maxLongitude, maxLatitude]
Useful for viewport calculations and spatial indexing
Example Usage: "What's the bounding box for this route?"
Buffer Tool
Create a buffer zone (polygon) around a point, line, or polygon.
Features:
Supports multiple distance units
Creates circular buffers around points
Useful for proximity analysis and creating zones of influence
Example Usage: "Show me a 5km buffer zone around this location"
Simplify Tool
Reduce the number of vertices in a line or polygon using the Douglas-Peucker algorithm.
Features:
Configurable tolerance for detail level
Preserves overall shape while reducing complexity
Useful for reducing file sizes and improving rendering performance
Option to maintain topology (prevent self-intersections)
Example Usage: "Simplify this complex boundary to reduce the number of points"
Length Tool
Measure the total length of a line defined by a series of coordinates.
Features:
Supports kilometers, miles, meters, and feet
Useful for measuring a drawn route, path, or boundary without a routing API call
Example Usage: "How long is this hiking trail?"
Convex Tool
Compute the convex hull of a set of points — the smallest convex polygon containing all of them.
Features:
Useful for bounding-area analysis or estimating coverage area
Works offline without API calls
Example Usage: "What's the smallest polygon that contains all of these store locations?"
Nearest Point Tool
Find the nearest point in a collection to a given target point.
Features:
More efficient than calling
distance_toolfor each candidate and sortingUseful for finding the closest store, stop, or landmark to a location
Example Usage: "Which of these stores is closest to my current location?"
Nearest Point on Line Tool
Snap a point to the nearest position on a line or route, returning that point and the distance to it.
Features:
Useful for "which point on this route is closest to my location?" or map-matching without an API call
Example Usage: "Where on this hiking trail am I closest to right now?"
Union, Intersect, and Difference Tools
Combine or compare two or more polygons — union_tool merges them into one geometry, intersect_tool finds the area they share, and difference_tool subtracts one from another.
Features:
Useful for combining service areas, finding coverage overlap, or computing exclusion zones (e.g. "what's covered by zone A but not zone B?")
Works entirely offline — no API calls required
Each returns a
render_map_toolreference so the result can be visualized directly
Example Usage: "Combine these two delivery zones into one coverage area" / "Where do these two isochrones overlap?" / "What part of this service area isn't covered by our 15-minute isochrone?"
Mapbox API Tools
Category List Tool (Deprecated)
⚠️ Deprecated: Use the resource_reader_tool with URI mapbox://categories instead, or access the mapbox://categories resource directly if your client supports MCP resources.
This tool is maintained for backward compatibility with clients that don't support MCP resources or the resource_reader_tool.
Matrix Tool
Calculates travel times and distances between multiple points using Mapbox Matrix API. Features include:
Efficient one-to-many, many-to-one or many-to-many routing calculations
Support for different travel profiles (driving-traffic, driving, walking, cycling)
Departure time specification for traffic-aware calculations
Route summarization with distance and duration metrics
Control approach (curb/unrestricted) and range of allowed departure bearings
Static image tool
Generates static map images using the Mapbox static image API. Features include:
Custom map styles (streets, outdoors, satellite, etc.)
Adjustable image dimensions and zoom levels
Support for multiple markers with custom colors and labels
Overlay options including polylines and polygons
Auto-fitting to specified coordinates
Category search tool
Performs a category search using the Mapbox Search Box category search API. Features include:
Search for points of interest by category (restaurants, hotels, gas stations, etc.)
Filtering by geographic proximity
Customizable result limits
Rich metadata for each result
Support for multiple languages
Reverse geocoding tool
Performs reverse geocoding using the Mapbox geocoding V6 API. Features include:
Convert geographic coordinates to human-readable addresses
Customizable levels of detail (street, neighborhood, city, etc.)
Results filtering by type (address, poi, neighborhood, etc.)
Support for multiple languages
Rich location context information
Ground location tool
Answers "what's near this coordinate" questions in a single call — place name, nearby points of interest, and travel-time reachability — sourced from live Mapbox data with citations. Use this instead of chaining reverse_geocode_tool with a web search.
Features:
Classifies the query (routing, neighborhood context, POI search, or region/reachability) and fetches only the relevant data
Nearby POI search by category, when requested
Travel-time reachability summary (isochrone-based)
Returns a
render_map_toolreference with the grounded location and nearby POIs plotted
Example Usage: "What neighborhood is this coordinate in, and are there any coffee shops nearby?"
Place details tool
Retrieves detailed information about a specific place using its Mapbox ID — photos, opening hours, ratings, phone numbers, and website URLs. Use after search_and_geocode_tool, category_search_tool, or reverse_geocode_tool to get more detail on a specific result.
Example Usage: "Tell me more about that first coffee shop result — hours, phone number, and website"
Directions tool
Fetches routing directions using the Mapbox Directions API. Features include:
Support for different routing profiles: driving (with live traffic or typical), walking, and cycling
Route from multiple waypoints (2-25 coordinate pairs)
Alternative routes option
Route annotations (distance, duration, speed, congestion)
Scheduling options:
Future departure time (
depart_at) for driving and driving-traffic profilesDesired arrival time (
arrive_by) for driving profile only
Profile-specific optimizations:
Driving: vehicle dimension constraints (height, width, weight)
Exclusion options for routing:
Common exclusions: ferry routes, cash-only tolls
Driving-specific exclusions: tolls, motorways, unpaved roads, tunnels, country borders, state borders
Custom point exclusions (up to 50 geographic points to avoid)
GeoJSON geometry output format
Isochrone tool
Computes areas that are reachable within a specified amount of times from a location using Mapbox Isochrone API. Features include:
Support for different travel profiles (driving, walking, cycling)
Customizable travel times or distances
Multiple contour generation (e.g., 15, 30, 45 minute ranges)
Optional departure or arrival time specification
Color customization for visualization
Search and geocode tool
Uses the Mapbox Search Box Text Search API endpoint to power searching for and geocoding POIs, addresses, places, and any other types supported by that API. This tool consolidates the functionality that was previously provided by the ForwardGeocodeTool and PoiSearchTool (from earlier versions of this MCP server) into a single tool.
Map matching tool
Snaps GPS traces to the road network using the Mapbox Map Matching API. Features include:
Convert noisy GPS traces to clean routes on the road network
Support for different travel profiles (driving, driving-traffic, walking, cycling)
Handle up to 100 coordinate pairs per request
Optional timestamps for improved accuracy based on speed
Configurable snap radiuses for different GPS quality levels
Route annotations (speed limits, distance, duration, traffic congestion)
Multiple geometry output formats (GeoJSON, polyline)
Example Usage: "Clean up this GPS trace and snap it to roads: [coordinates with timestamps]"
Optimization tool
Finds the optimal route through multiple locations using the Mapbox Optimization API. Features include:
Solve traveling salesman problem (TSP) for 2-12 locations
Support for different travel profiles (driving, driving-traffic, walking, cycling)
Flexible start and end point configuration
Roundtrip or one-way trip optimization
Turn-by-turn navigation instructions (optional)
Route annotations (distance, duration, speed)
Multiple geometry output formats (GeoJSON, polyline)
Example Usage: "Find the optimal route to visit these 5 stops: [list of addresses or coordinates]"
Note: A V2 API with advanced features (time windows, capacity constraints, multiple vehicles) is available but requires beta access. The V2 implementation is included in the codebase but not registered by default.
Elevation tool
Gets ground elevation from Mapbox's terrain data (Mapbox Terrain-DEM v1). Give it up to 25 places for the height above sea level of each, or a line for:
Total climb and descent
The highest and lowest points, and how far along the line they are
An elevation profile of up to 50 points
The line can be a path of coordinates, or the route_ref from a directions_tool or map_matching_tool result, which the tool turns back into the full route itself. The server reads the terrain tiles and decodes each pixel's height, so values aren't rounded to contour steps the way Tilequery's Terrain v2 contours are. Points along a line share tiles, and long lines are read at a coarser zoom so a call stays under 50 tile requests; resolution_m in the result says how coarse. Swings under 2 m don't count toward climb or descent, so DEM noise on flat ground doesn't add up. Heights are of the ground, not of buildings or bridges. The result includes a map ref with the line and its high and low points.
Example Usage: "How hilly is the bike route from the Ferry Building to Twin Peaks?" or "How high is Longs Peak?"
Feedback tool
Sends a user's feedback about the app or agent to its developer, through the Mapbox Feedback API (Public Preview). It's filed under the account that owns the access token, so when you build an app or agent on this server with your own token, your users' feedback lands in the same feed as your apps' Feedback Agent reports, and you review it in Feedback Explorer. It does not report problems to Mapbox. Like Feedback Agent, it's for anything about your product that helps you understand what users need, for example:
A place that has closed, has wrong details, or sits on the wrong spot
A place or address that can't be found
A closed road, a wrong speed limit, or traffic shown wrong
A route with an illegal turn or entrance, or no route at all
Something about the app itself, such as a bug or a suggestion (
application_issue)
It sends the feedback text, a category and the location, and returns the item's id and status. The location is optional, for feedback that isn't about a place; the API requires one, so the tool sends 0, 0, as the Feedback API team recommends for now. Nothing is sent without the user's go-ahead: clients that support elicitation show a confirmation prompt first, and the tool description asks the model to confirm in chat everywhere else.
The Feedback API is free during Public Preview. At General Availability, Feedback Agent charges $0.02 per feedback item. To avoid filing the same problem twice, before sending the tool checks the account's own reports from the last 30 days. If one in the same category within 50 m is still awaiting review (feedback without a location isn't checked), it returns that report instead of sending a new one. The Feedback API only lists the account's own reports, so this can't catch reports from other accounts. send_anyway: true skips the check when the user says theirs is a different problem.
Requirements: the access token needs the user-feedback:write scope to send, and user-feedback:read for the duplicate check. Without the write scope the tool returns an error saying so. Without the read scope it sends without checking and says so in its result. To leave the tool out, start the server with --disable-tools feedback_tool.
Example Usage: "Blue Bottle on Mint St closed last year, can you send that as feedback?"
Report tool
Sends feedback about the Mapbox MCP server itself to the Mapbox team that builds it: a bug, a tool that gave a wrong or confusing result, a missing capability or a suggestion. It's filed under Mapbox's own account, not yours, so it needs no extra token scope, and it can't be read back or withdrawn afterward. It isn't for reporting wrong map, place or routing data.
The server adds its version, the client's name and version, and the tool the feedback is about to the end of the text. Nothing is sent without the user's go-ahead: clients that support elicitation show a confirmation prompt first, and the tool description asks the model to confirm in chat everywhere else.
It uses the endpoint the Feedback API team added for the Mapbox CLI's mapbox report command. To leave the tool out, start the server with --disable-tools report_tool.
Example Usage: "The map didn't draw any of my isochrones. Can you let the Mapbox MCP team know?"
List public tokens tool
Lists the account's public (pk.) access tokens, for an agent building a web page or app outside the chat that loads Mapbox GL JS or calls Mapbox APIs from the browser. In the chat, render_map_tool needs no token. Each token comes with its name, whether it's the default, its URL restrictions and its scopes.
Pass site_url (where the page will run) and the tool recommends a token restricted to that URL when the account has one. Otherwise it recommends the default public token and says that a published site should use a URL-restricted token instead, with a link to create one. Anyone who copies an unrestricted public token can use it, and the usage bills to the account.
It never returns secret or temporary tokens, and it can't create tokens (that needs tokens:write; the DevKit server's create_token_tool does it).
Requirements: listing needs the tokens:read scope, the same one the in-chat map already uses to find the default public token. With a pk. access token, or when listing fails on the server's own MAPBOX_ACCESS_TOKEN and MAPBOX_PUBLIC_TOKEN is set, it returns that token instead. A caller with its own bearer token (the hosted server) never gets MAPBOX_PUBLIC_TOKEN, and a token restricted to other URLs is never recommended. To leave the tool out, start the server with --disable-tools list_public_tokens_tool.
Example Usage: "Build me a single-page site that shows our three store locations on a Mapbox map."
Development
Inspecting server
Using Node.js
# Run the built image
npm run inspect:buildUsing Docker
# Build the Docker image
docker build -t mapbox-mcp-server .
# Run and inspect the server
npx @modelcontextprotocol/inspector docker run -i --rm --env MAPBOX_ACCESS_TOKEN="YOUR_TOKEN" mapbox-mcp-serverCreate new tool
npx plop create-tool
# provide tool name without suffix (e.g. Search)Releasing a New Version
# 1. Bump version in package.json
npm version <new-version> --no-git-tag-version
# 2. Sync version to manifest.json and server.json
npm run sync-manifest
# 3. Prepare CHANGELOG (replaces "Unreleased" with version and date)
npm run changelog:prepare-release <new-version>
# 4. Update package-lock.json
npm install
# 5. Review changes, then commit and tag
git add package.json package-lock.json manifest.json server.json CHANGELOG.md
git commit -m "Release v<new-version>"
git tag v<new-version>
git push && git push --tagsImportant: The publisher workflow validates that package.json and server.json versions match the release version. Skipping the version bump or manifest sync will cause publish failures.
OpenTelemetry Tracing
This MCP server includes comprehensive OpenTelemetry tracing for production observability:
Quick Demo
# 1. Copy the example configuration
cp .env.example .env
# 2. Edit .env to add your MAPBOX_ACCESS_TOKEN and configure tracing
# 3. Start Jaeger for local development
npm run tracing:jaeger:start
# 4. Run the server (it will automatically use .env configuration)
npm run inspect:build
# 5. View traces at http://localhost:16686
# 6. Stop Jaeger when done
npm run tracing:jaeger:stopNote: The server automatically loads configuration from your .env file at startup. The .env.example file includes configuration examples for multiple observability platforms.
Supported Observability Platforms
Configuration examples included in .env.example for:
Cloud Providers:
☁️ AWS X-Ray
☁️ Azure Monitor (Application Insights)
☁️ Google Cloud Trace
SaaS Platforms:
📊 Datadog
📊 New Relic
📊 Honeycomb
📊 Any OTLP-compatible backend
Production Configuration
See docs/tracing.md for complete setup instructions including:
🔧 Platform-specific configuration guides
📊 Authentication and endpoint setup
🎯 Custom trace attributes and context
🚀 Performance optimization (minimal overhead)
🔍 Troubleshooting and debugging
Tracing Features:
✅ Configuration loading tracing (.env file loading)
✅ Automatic tool execution tracing
✅ HTTP request instrumentation with CloudFront correlation IDs
✅ Configurable exporters (console, OTLP)
✅ Security-conscious (data protection, JWT validation)
✅ Production-ready (<1% CPU overhead)
Contributing
We welcome contributions to the Mapbox MCP Server! Please read CONTRIBUTING.md before submitting a pull request.
Full standards and guidelines:
CONTRIBUTING.md - Getting started, PR process, quick reference
Engineering Standards (docs/engineering_standards.md) - Complete code quality, testing, documentation, and collaboration standards
Claude Code Guide (CLAUDE.md) - Standards and patterns for contributors using Claude Code
AI Agent Instructions (AGENTS.md) - Guide for other AI coding assistants (Cursor, Continue, Aider, etc.)
GitHub Copilot Guidelines - Best practices for using GitHub Copilot responsibly
Quick Start for Contributors
Fork the repository and clone your fork
Install dependencies:
npm installMake your changes following our coding standards
Run tests and linting:
npm test && npm run lintAdd tests for any new functionality
Submit a pull request with a clear description
All contributions must pass our CI checks and code review process. See docs/engineering_standards.md for detailed requirements.
Data Usage & Privacy
What data is sent to Mapbox APIs
When you use the MCP server tools, the following data is sent directly from your environment to Mapbox APIs:
Geocoding tools: Address/location text, coordinates, country/region filters
Search tools: Search queries, location coordinates for proximity, category filters
Directions tool: Start/end coordinates, waypoints, routing preferences, vehicle constraints
Matrix tool: Multiple coordinate pairs, travel profile, departure times
Static map tool: Coordinates, zoom level, styling preferences, marker information
Isochrone tool: Origin coordinates, time/distance parameters, travel profile
Your privacy
Local execution: All API calls are made directly from your environment to Mapbox APIs
Token security: Your Mapbox API token remains on your local machine and is never transmitted to or stored by this MCP server
No data storage: This MCP server does not store, log, or collect any of your data or API requests
Direct communication: There is no intermediary server between you and Mapbox APIs
Third-party data usage
Mapbox's privacy policy governs data sent to their APIs: https://www.mapbox.com/legal/privacy/
API usage: Standard Mapbox API terms apply to all requests made through these tools
Data retention: Refer to Mapbox's documentation for their data retention policies
Support & Contact
For MCP Server Issues
Email: mcp-feedback@mapbox.com
GitHub Issues: Report bugs and feature requests
For Mapbox API Questions
Mapbox Support: https://support.mapbox.com/
Documentation: https://docs.mapbox.com/
API Status: https://status.mapbox.com/
Maintenance Commitment
This MCP server is officially maintained by Mapbox, Inc. We provide:
Regular updates for new Mapbox API features
Bug fixes and security updates
Compatibility with latest MCP protocol versions
Community support through GitHub issues
Available Tools
33 toolsarea_toolCalculate AreaBRead-onlyIdempotentInspect
Calculate the area of a polygon or multipolygon. Supports various units including square meters, kilometers, acres, and hectares. Works offline without API calls.
Inputs: geometry (required), units. Returns: area, units
bbox_toolCalculate Bounding BoxARead-onlyIdempotentInspect
Calculate the bounding box (extent) of any geometry. Returns the minimum and maximum longitude and latitude that encompass the geometry. Works offline without API calls.
Inputs: geometry (required). Returns: bbox
bearing_toolCalculate BearingARead-onlyIdempotentInspect
Calculate the bearing (compass direction) from one point to another. Returns bearing in degrees where 0° is North, 90° is East, 180° is South, and 270° is West. Works offline without API calls.
Inputs: to (required), from (required). Returns: to, from, bearing
buffer_toolCreate Buffer ZoneARead-onlyIdempotentInspect
Create a buffer zone (polygon) around a point, line, or polygon at a specified distance. Useful for proximity analysis, service areas, or creating zones of influence. Works offline without API calls.
Inputs: distance (required), geometry (required), units. Returns: units, distance, bufferedPolygon
category_search_toolCategory Search ToolARead-onlyIdempotentInspect
Return all places that match a category (industry, amenity, or NAICS‑style code). Use when the user asks for a type of place, plural or generic terms like 'museums', 'coffee shops', 'electric‑vehicle chargers', or when the query includes is‑a phrases such as 'any', 'all', 'nearby'. Do not use when a unique name or brand is provided. Supports both JSON and text output formats.
Inputs: category (required), bbox, limit, format, +4 more. Returns: type, features, attribution, mapboxRender
centroid_toolCalculate CentroidBRead-onlyIdempotentInspect
Calculate the geometric center (centroid) of a polygon or multipolygon. The centroid is the arithmetic mean position of all points in the shape. Works offline without API calls.
Inputs: geometry (required). Returns: centroid
convex_toolConvex HullARead-onlyIdempotentInspect
Compute the convex hull of a set of points — the smallest convex polygon that contains all the points. Useful for bounding area analysis, estimating coverage area, or wrapping a set of locations. Works offline without API calls.
Inputs: points (required). Returns: geometry, num_points
destination_toolCalculate DestinationARead-onlyIdempotentInspect
Calculate a destination point given a starting point, bearing, and distance using geodesic (great-circle) straight-line offset. Useful for "find a point 5km north of X", constructing search offsets, or computing waypoints. Bearing: 0=north, 90=east, 180/-180=south, -90=west. Note: this calculates a straight-line geographic offset, not road-network distance. Works offline without API calls.
Inputs: origin (required), bearing (required), distance (required), units. Returns: units, bearing, distance, destination
difference_toolDifference of PolygonsARead-onlyIdempotentInspect
Subtract one polygon from another, returning the area in polygon1 that is not covered by polygon2. Useful for computing exclusion zones, finding uncovered service areas, or "what is in zone A but not zone B?". Returns null geometry if polygon2 fully covers polygon1. Works offline without API calls. INPUT SHAPE: polygon1 and polygon2 are each an array of rings; each ring is an array of [lng, lat] pairs. When chaining with isochrone_tool, extract feature.geometry.coordinates from each isochrone Feature (with polygons=true).
Inputs: polygon1 (required), polygon2 (required). Returns: geometry, mapboxRender, has_difference
directions_toolDirections ToolARead-onlyIdempotentInspect
Fetches directions from Mapbox API based on provided coordinates and direction method. Returns a mapboxRender.ref in structuredContent regardless of the geometries value; if the user wants to see the route on a map, pass it to render_map_tool. Use geometries="none" (default) for compact text/data responses (distance, duration, turn-by-turn instructions, congestion). Use geometries="geojson" when you need the raw route coordinates in the response yourself, e.g. to draw the route in your own app. It defaults to a simplified geometry that keeps the route's shape when zoomed out but cuts corners up close; pass overview="full" for every vertex when your map lets people zoom in on the route. render_map_tool works either way. Only overview="full" on a very long trip can exceed the response size limit; then this tool returns a summary and a mapbox://response/... ref you can read with the MCP resources API.
Inputs: coordinates (required), exclude, overview, arrive_by, +7 more. Returns: code, uuid, routes, waypoints, +1 more
distance_toolCalculate DistanceARead-onlyIdempotentInspect
Calculate the distance between two geographic coordinates. Supports various units including kilometers, miles, meters, feet, and nautical miles. Uses the Haversine formula for accurate great-circle distance calculations. This tool works offline without requiring API calls.
Inputs: to (required), from (required), units. Returns: to, from, units, distance
elevation_toolElevation ToolARead-onlyIdempotentInspect
Gets ground elevation from Mapbox terrain data. Give it places (points) for the height above sea level of each, or a line (path, or route_ref from a directions_tool or map_matching_tool result) for total climb and descent, the highest and lowest points, and an elevation profile. Use it for questions like "how high is this town?", "how hilly is this bike route?", "how much climbing is on this trail run?" or, for a recorded GPS trace matched with map_matching_tool, "how much did I climb?". Elevations are of the ground (bare earth), not buildings or bridges. Long paths are read at a coarser resolution (see resolution_m in the result), which can undercount small hills.
Inputs: path, points, route_ref. Returns: path, zoom, points, source, +2 more
feedback_toolSend Feedback to the DeveloperAInspect
Send the user's feedback about this app or agent to its developer, through the Mapbox Feedback API (Public Preview), so the developer can understand what users need and improve the product. Feedback can be about anything in the product: for example a place that has closed or has wrong details, a missing place, a closed road, a route with an illegal turn, a wrong travel time, or something about the app itself. It is filed under the Mapbox account that owns the access token, in the same feed as that account's Feedback Agent reports, and the developer reviews it in Feedback Explorer. It does not report the problem to Mapbox. Use it only when the user asks to send feedback, or agrees when you offer. Before calling it, show the user the exact feedback text, category and location you will send and get their go-ahead. Take the coordinates from an earlier search, place or directions result rather than guessing, and leave them out when the feedback is not about a place, such as most feedback about the app itself. Send one report per problem, and do not resend one that already succeeded. To avoid filing the same problem twice, the tool first checks the account's own reports from the last 30 days and does not send if one with the same category within 50 m is still awaiting review; it returns that report instead. Only set send_anyway when the user says the earlier report is about a different problem. Returns the item id and its status (received).
Inputs: category (required), feedback (required), coordinates, send_anyway. Returns: id, status, category, feedback, +6 more
ground_location_toolGround Location ToolARead-onlyIdempotentInspect
Answer questions about what is near a location, what neighborhood a coordinate is in, or what places are within walking/driving distance. Use this when given coordinates and asked about nearby places, neighborhood context, local discovery, or area summaries. It already includes reverse geocoding, so a separate reverse_geocode_tool call is not needed for the same coordinate. Pass the place category (e.g. "restaurant", "coffee", "park") as the query parameter to get nearby POIs in the same call. Returns place name, nearby POIs matching the query, and travel-time reachability — all sourced from live Mapbox data with citations. Use include for what the spot itself is: land use (is it in a park, a national park, a building?), water (on it, or how near), elevation, and live traffic on the roads around it. So use it for "is this spot in a park?", "is this on the water?" or "how bad is traffic at this address?" too. For elevation along a path or route, use elevation_tool.
Inputs: latitude (required), longitude (required), limit, query, +4 more. Returns: land, place, water, traffic, +8 more
intersect_toolIntersect PolygonsARead-onlyIdempotentInspect
Find the intersection geometry of two polygons — the area they share in common. Useful for coverage overlap analysis, finding shared service areas, or zone overlap. Returns null geometry if the polygons do not overlap. Works offline without API calls. INPUT SHAPE: polygon1 and polygon2 are each an array of rings; each ring is an array of [lng, lat] pairs. When chaining with isochrone_tool, extract feature.geometry.coordinates from each isochrone Feature (with polygons=true).
Inputs: polygon1 (required), polygon2 (required). Returns: geometry, intersects, mapboxRender
isochrone_toolIsochrone ToolARead-onlyIdempotentInspect
Computes areas that are reachable within a specified amount of time from a location, and returns the reachable regions as contours of Polygons or LineStrings in GeoJSON format that you can display on a map. Common use cases: - Show a user how far they can travel in X minutes from their current location - Determine whether a destination is within a certain travel time threshold - Compare travel ranges for different modes of transportation'
Inputs: generalize (required), coordinates (required), denoise, exclude, +6 more. Returns: type, features, mapboxRender
length_toolMeasure Line LengthARead-onlyIdempotentInspect
Measure the total length of a line defined by a series of coordinates. Useful for measuring a drawn route, path, or boundary without a routing API call. Supports kilometers, miles, meters, and feet. Works offline without API calls.
Inputs: coordinates (required), units. Returns: units, length, num_coordinates
list_public_tokens_toolList Public TokensARead-onlyIdempotentInspect
Lists the Mapbox account's public (pk.) access tokens, for when you build a web page or app outside this chat that loads Mapbox GL JS or calls Mapbox APIs from the browser. Put the returned pk. token in the page: public tokens are made to ship in browser code, so a placeholder or asking the user to paste a token is not needed. To show a map in the chat, use render_map_tool instead; it needs no token. Pass site_url (where the page will run) to get a token restricted to that URL when the account has one. Returns each token's name, whether it is the default, its URL restrictions and scopes, a recommended token, and guidance: for a published site, use a URL-restricted token, and tell the user the default token can be reused by anyone who copies it. Secret tokens are never listed.
Inputs: site_url. Returns: tokens, guidance, recommended
map_matching_toolMap Matching ToolARead-onlyIdempotentInspect
Snap a recorded GPS trace to roads using Mapbox Map Matching API. Takes a dense, noisy coordinate sequence (2-100 points, recorded seconds or tens of meters apart) and returns a clean route aligned with actual roads, bike paths, or walkways. Useful for analyzing recorded trips, cleaning fleet tracking data, or processing fitness activity traces. Not for routing between a few places or addresses: points kilometers apart fail to match, so use directions_tool for that. Returns confidence scores, matched geometry, and optional traffic/speed annotations.
Inputs: coordinates (required), profile, overview, radiuses, +3 more. Returns: code, matchings, tracepoints, mapboxRender
matrix_toolMatrix ToolARead-onlyIdempotentInspect
Calculates travel times and distances between multiple points using Mapbox Matrix API. Put all the points in one call (up to 25, 10 for driving-traffic) rather than one call per pair: the API allows 60 requests per minute (30 for driving-traffic).
Inputs: profile (required), coordinates (required), sources, bearings, +3 more. Returns: code, message, sources, distances, +2 more
midpoint_toolCalculate MidpointARead-onlyIdempotentInspect
Calculate the geographic midpoint between two coordinates. Returns the point that is halfway between the two input points along the great circle path. Works offline without API calls.
Inputs: to (required), from (required). Returns: to, from, midpoint
nearest_point_on_line_toolNearest Point on LineARead-onlyIdempotentInspect
Snap a point to the nearest position on a line or route. Returns the closest point on the line and the distance to it. Useful for "which point on this route is closest to my location?" or map-matching without the API. Works offline without API calls.
Inputs: line (required), point (required), units. Returns: units, nearest, distance, location
nearest_point_toolNearest PointARead-onlyIdempotentInspect
Find the nearest point in a collection to a given target point. More efficient than calling distance_tool for each candidate and sorting. Useful for finding the closest store, stop, or landmark to a location. Works offline without API calls.
Inputs: points (required), target (required), units. Returns: index, units, nearest, distance
optimization_toolOptimize Multi-Stop RouteARead-onlyIdempotentInspect
Find the optimal (shortest by travel time) route through a set of 2-12 coordinates. Solves the Traveling Salesman Problem to determine the best visiting order. Supports options for starting point, ending point, and whether to return to start.
Inputs: coordinates (required), steps, source, profile, +6 more. Returns: code, trips, message, waypoints, +1 more
place_details_toolPlace Details ToolARead-onlyIdempotentInspect
Retrieve detailed information about a specific place using its Mapbox ID. Use after search_and_geocode_tool, category_search_tool, or reverse_geocode_tool to get additional details such as photos, opening hours, phone numbers, and website URLs. Requires the mapbox_id field from a previous search result. Primarily covers points of interest (businesses, addresses, buildings); mapbox_ids for neighborhoods, cities, or other administrative boundaries are also supported but return more limited data (name, address, coordinates — no photos, hours, or contact info). The primary POI lookup is Public Preview with a default quota of 1,000 requests/month; contact Mapbox if you need a higher volume.
Inputs: mapbox_id (required), language, worldview, attribute_sets. Returns: bbox, name, brand, phone, +20 more
points_within_polygon_toolPoints Within PolygonARead-onlyIdempotentInspect
Test one or more geographic points against a polygon, returning only those inside. Handles a single point or a batch of points in one call. Useful for delivery zone validation, fleet geofencing, and customer segmentation. Works offline without API calls.
Inputs: points (required), polygon (required). Returns: count, total, points_within
render_map_toolMapbox MapARead-onlyIdempotentInspect
Display a live, interactive Mapbox GL JS map. Use this when someone wants to see a location, route, or dataset on a map. In ChatGPT Desktop the map stays open next to the chat and provides its own tools (redraw_map, which takes the same arguments as this tool, search_map, add_places, move_map, read_map): use them to change that map, because another call to this tool opens a second map. Preferred usage: any other Mapbox tool returns a mapboxRender.ref URI in its structuredContent — pass that ref via payload_refs: ["..."]. You can pass multiple refs to merge several datasets (e.g. a search result + a route) onto one map. Inline layers/markers/legend fields are also supported for hand-composed payloads from raw GeoJSON. For a hand-composed POI marker (e.g. built from category_search_tool/search_and_geocode_tool/place_details_tool output), set markers[].id to the place's mapbox_id — this gets it the same auto-enriching results carousel (popularity score and photo) that a payload_refs-based search result gets automatically, with no extra tool calls. To restyle the base map itself (e.g. "make the water red", switch to night lighting, hide POI labels) pass baseMapConfig. To switch to satellite imagery, pass baseStyle: "standard-satellite" (defaults to "standard"). To show live traffic congestion on the roads in view, pass showTraffic: true. The map also has Satellite and Traffic buttons users can toggle themselves. Every call redraws the map from scratch: only the traffic and satellite settings carry over from the previous call. So to restyle an already-drawn map or toggle traffic without losing its content, re-pass the same payload_refs/layers alongside baseMapConfig/baseStyle/showTraffic rather than sending them alone. After rendering places, don't list them again in your reply: the map's cards already show each name, category, price level, distance and hours. Answer the question or add what the cards leave out (like the phone number or address) instead.
Inputs: camera, layers, legend, markers, +5 more. Returns: summary, rendered, layer_count, mapboxRender, +1 more
report_toolSend Feedback to MapboxAInspect
Send feedback about the Mapbox MCP server to the Mapbox team that builds it: a bug, a tool that failed or gave a wrong or confusing result, a missing capability or a suggestion. It goes to Mapbox, not to the user's account, needs no special token scope, and cannot be read back or withdrawn afterward. It is for feedback about this server, not for reporting wrong map, place or routing data. Use it only when the user asks to send feedback, or agrees when you offer. Before calling it, show the user the exact text you will send and get their go-ahead. Leave out personal details the user did not ask to share. The server adds its own version and the client name. Send one report per problem, and do not resend one that already succeeded. Returns the report id.
Inputs: category (required), feedback (required), tool_name. Returns: id, status, category, feedback
reverse_geocode_toolReverse Geocode ToolARead-onlyIdempotentInspect
Convert geographic coordinates (longitude, latitude) into a human-readable address or place name. Use only when you need an address/place name alone. If you also need nearby places, neighborhood context, or travel-time reachability, use ground_location_tool instead — it already includes reverse geocoding plus POI search and isochrone in one call. This tool cannot reverse geocode businesses, landmarks, or POIs. Supports JSON and text output formats.
Inputs: latitude (required), longitude (required), limit, types, +5 more. Returns: type, features, attribution
search_and_geocode_toolSearch and Geocode ToolARead-onlyIdempotentInspect
Search for POIs, brands, chains, geocode cities, towns, addresses. Do not use for generic place types such as 'museums', 'coffee shops', 'tacos', etc, because category_search_tool is better for that. Setting a proximity point is strongly encouraged for more local results. The underlying Search Box API is rolling out natural-language query understanding (e.g. 'quiet coffee shops with wifi near downtown'), so richer free-text phrasing in q can work well for category + place + attribute combinations — but as of this writing, big-box retail brand searches tied to a specific address (e.g. 'Costco near ', 'Walmart near ', 'Target near ') are unreliable and often return unrelated results; verify those results before relying on them.
Inputs: q (required), bbox, types, origin, +7 more. Returns: type, features, attribution, mapboxRender
simplify_toolSimplify GeometryARead-onlyIdempotentInspect
Simplify a LineString or Polygon by reducing the number of vertices while preserving the general shape. Uses the Douglas-Peucker algorithm. Useful for reducing file sizes and improving rendering performance. Works offline without API calls.
Inputs: geometry (required), tolerance, highQuality. Returns: simplified, originalVertexCount, reductionPercentage, simplifiedVertexCount
static_map_image_toolStatic Map Image ToolARead-onlyIdempotentInspect
Generates a static map image from Mapbox Static Images API. Supports center coordinates, zoom level (0-22), image size (up to 1280x1280), various Mapbox styles, and overlays (markers, paths, GeoJSON). Returns PNG for vector styles, JPEG for raster-only styles. Use only when the user explicitly asks for a static image file — to show a map, use render_map_tool instead, which renders an interactive map.
Inputs: size (required), zoom (required), center (required), style, +2 more.
union_toolUnion PolygonsARead-onlyIdempotentInspect
Merge two or more polygons into a single unified geometry. Useful for combining service areas, delivery zones, isochrones, or coverage regions. Returns a Polygon or MultiPolygon if the inputs do not overlap. Works offline without API calls. INPUT SHAPE: pass polygons as an array of polygons. Each polygon is an array of rings; each ring is an array of [lng, lat] pairs. When chaining with isochrone_tool, extract feature.geometry.coordinates from each isochrone Feature — that is already a valid Polygon value. Skip features whose geometry.type === "MultiPolygon" (pass each inner Polygon separately) or whose geometry.type === "LineString" (set isochrone_tool polygons=true to get Polygon output instead).
Inputs: polygons (required). Returns: type, geometry, mapboxRender
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 33 tools
Most tools have clearly distinct operations, and the descriptions actively clarify boundaries between overlapping areas such as render_map_tool vs static_map_image_tool, ground_location_tool vs reverse_geocode_tool, and directions_tool vs map_matching_tool. A few geometry utilities and search/location tools could still be confused at a glance, but the descriptions usually resolve the ambiguity.
All tools follow a consistent snake_case naming convention with a uniform `_tool` suffix. The names are descriptive and predictable, even though some are verb-first and others noun-first.
With 33 tools, the surface is heavy for a single MCP server and exceeds the typical well-scoped range. While many tools are individually justified by Mapbox's broad domain, the large number increases selection burden and makes the set harder to navigate.
The surface covers a wide range of Mapbox capabilities: geocoding, category search, place details, routing, isochrones, matrices, optimization, map matching, elevation, static and interactive rendering, feedback, token listing, and offline geometry operations. There are minor gaps, such as style listing or more advanced token management, but core workflows are well covered.
Maintenance
Related MCP Connectors
Provides AI assistants with direct access to Mapbox developer APIs and documentation.
Routing, geocoding, places, matrix and map tools for location-aware AI workflows.
Geocoding, routing, isochrones, traffic, weather, and place search for AI agents. 19 MCP tools.
Geodata for any place, inside your agent: map data, terrain, routes, satellite images, GIS files.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnhances LLM capabilities with location-based services and geospatial data, enabling users to geocode addresses, find nearby points of interest, get directions, optimize meeting points, and analyze neighborhoods.12237MIT
- AlicenseNot gradedqualityDmaintenanceProvides AI applications with geospatial intelligence through Mapbox APIs, enabling geocoding, POI search, routing, travel time analysis, isochrone generation, and static map creation for location-aware functionality.BSD 3-Clause

ThinAir Geoofficial
AlicenseAqualityBmaintenanceLocation & routing intelligence for AI agents — geocoding, truck routing, traffic, weather, and place search.1911 npm1MIT
Magic Lane MCP Serverofficial
AlicenseBqualityCmaintenanceEnables AI agents to become geospatially intelligent assistants with tools for location search, smart routing, round trip planning, reverse geocoding, isochrone analysis, route visualization, geofence management, and interactive map display.812 npm8Apache 2.0