Overpass MCP for AI. Query Global OpenStreetMap Data Directly
Gemini Works with every AI agent you already use
…and any MCP-compatible client
How this MCP server connects to your AI agent
Overpass MCP Server executes complex spatial queries against OpenStreetMap data. Use this server to find specific points of interest (POIs), extract raw map segments for a bounding box, or check your current API rate limits.
It lets your AI agent run deep geospatial analysis using Overpass QL.
What AI agents can do with Overpass Automation
Execute query
Runs a full Overpass QL query and returns the results in structured JSON format.
Get map
Fetches all OSM map data (nodes, ways, relations) within a specified bounding box and returns it as raw XML.
Get status
Checks the current API slot availability and rate limit status for your Overpass account.
Finds and returns structured data (POIs, ways, relations) from OSM based on a complex Overpass QL query.
Fetches all node, way, and relation data within specified coordinates into raw XML format for GIS processing.
Checks your current usage status to prevent request throttling when running large datasets or multiple queries.
Executes queries written in the older XAPI syntax for systems that haven't updated their API calls.
Ask an AI about this
Waiting for input…
What AI agents can do with Overpass: 4 Tools for Geospatial Queries
These four tools let your agent perform everything from complex feature queries to fetching raw map data directly from OpenStreetMap.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Overpass on VinkiusExecute Query
Runs a full Overpass QL query and returns the results in structured JSON format.
Get Map
Fetches all OSM map data (nodes, ways, relations) within a specified bounding box...
Get Status
Checks the current API slot availability and rate limit status for your Overpass...
Execute Xapi
Executes a legacy XAPI query, returning raw XML data for older systems.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The Overpass integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Overpass, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Overpass API. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Built on the Model Context Protocol (MCP) for Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 4 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Pulling raw geographic data used to feel like an archaeological dig., Solved with Vinkius AI Gateway
Today, getting detailed spatial info means jumping through hoops. You click the mapping service, you filter by feature type (e.g., 'park'), then you manually draw a boundary box that covers your area of interest. Then you export it—usually as an XML or GeoJSON file—and hope it has everything you need without missing critical nodes.
With this MCP server, the process is one command. You tell your agent exactly what features and where you want them. It runs `execute_query`, pulls the data directly from OSM's live database, and sends back a structured result that your code can use instantly. No manual exports, no lost nodes.
Overpass MCP Server: Get map data with `get_map`
The old way required running multiple API calls—one for the points of interest, another for the roads, and sometimes a third just to get the underlying raw geometry. You'd end up stitching together several incomplete pieces in your local GIS software.
Now you run `get_map`. This single tool fetches all nodes, ways, and relations within your defined bounding box into one raw XML file. It gives you the entire map segment—the complete source material—in a single step.
What your AI can actually do with this
Overpass MCP Server - Querying OSM Data
You don't write complex HTTP calls just to get map data. This server connects your AI agent right into the OpenStreetMap database, letting you run deep geospatial analysis using Overpass QL. It’s built for when you need specific coordinates or raw map segments, and it handles the heavy lifting so you can focus on what you gotta do with the data.
Executing Deep Queries for Specific Features
When you're looking for something precise—say, every single public park or all the bike paths in a neighborhood—you use execute_query. This tool runs a full Overpass QL query and spits out the results as structured JSON. You don’t get messy text dumps; you get clean data that your agent can read immediately.
It finds specific Points of Interest (POIs), extracts detailed ways, or pulls back relations based on complex criteria you define in your query. This function is how you find all fire stations, utility boxes, or historical markers within a defined area without manually sifting through layers of raw XML.
If the features you need are more varied—you gotta pull everything from nodes to ways and relations for an entire region—you'll use get_map. This tool fetches every piece of OpenStreetMap data (nodes, ways, and relations) within a specified bounding box. It returns all that info as raw XML, which is what you need if you’re feeding the map into a specialized GIS program or doing deep spatial processing outside of Overpass QL itself.
Handling Legacy Systems and Rate Limits
Sometimes, the system you're talking to hasn't caught up with modern APIs. For those older setups that still use XAPI syntax, you run execute_xapi. This tool executes queries written in that older format, giving you raw XML data so your agent doesn't hit a compatibility wall because of outdated API calls.
It keeps those legacy systems talking to the latest map data.
You gotta watch your usage though; you don’t want your job bombing out halfway through because the rate limit hit zero. You check that with get_status. This tool tells you exactly what your current API slot availability is and gives you real-time status on your Overpass account, letting you plan around request throttling when you're running huge datasets or a bunch of consecutive queries.
In short, this server lets your agent handle everything from finding structured data sets using modern QL queries to dumping raw XML for GIS processing via get_map, and it even manages the housekeeping—checking limits with get_status and supporting old XAPI syntax when you need it. You're talking about a complete geospatial toolkit, all running through one connection.
019e5d41-9410-708e-afd3-6cd7639d0246 
Here's how it actually works
The bottom line is: you ask your AI client a question about the physical world, and it gets back the raw map data needed to answer it.
First, ensure your AI agent has access to the Overpass API endpoint. You can optionally configure a custom instance URL if needed.
Next, tell your agent exactly what you need—for example, 'Find all public swimming pools in downtown Chicago.'
The agent calls the appropriate tool (execute_query, get_map, etc.), runs the query against OSM, and sends back structured data (JSON or XML) based on the result.
Who is this actually for?
GIS Analysts, Urban Planners, Data Scientists, and Backend Engineers. You need this when querying real-world, non-structured spatial data is part of your job. If your workflow involves finding physical locations or mapping infrastructure, you'll run into limits that standard databases can't solve.
Uses execute_query to automate feature extraction for research models, pulling specific geometries like river paths or zoning lines.
Runs queries to map and analyze city infrastructure—for instance, checking the density of public bike lanes across a whole district.
Integrates real-world geographic data into an application using get_map to fetch raw OSM XML for rendering or processing.
What Changes When You Connect
Deep Feature Extraction: Use execute_query to pinpoint specific features (like schools or bus stops) by writing Overpass QL. You don't have to manually filter massive datasets; the query handles it.
Full Map Segmentation: If you need a complete snapshot of an area for specialized GIS processing, get_map fetches all raw OSM XML data for a bounding box, ensuring no nodes or ways are missed.
Predictable Usage: Never hit a rate limit mid-job. Run get_status first to check your remaining API slots and make sure you have capacity before launching large queries.
Compatibility Layer: The execute_xapi tool lets your agent run against older XAPI syntax, ensuring that legacy applications still get the map data they need without a code rewrite.
Actionable Data Types: Results are returned in JSON for structured queries or raw XML/JSON for mapping. Your AI client gets clean output ready for immediate use.
See it in action
Mapping all public water sources for a utility project
A planner needs to know every cistern and fountain in a neighborhood. They ask their agent: 'Find all fountains within this area.' The agent uses execute_query with the specific Overpass QL filter, returning a structured JSON list of coordinates and details for immediate review.
Building a map visualization from scratch
A developer needs the complete raw data dump for an old section of town. They use get_map to fetch all nodes, ways, and relations into one XML file. This gives them the foundational layer needed to build their own custom mapping service.
Running a massive query batch job
A research team is running dozens of queries across a large city. Before starting, they first call get_status to verify available API slots. This prevents the entire workflow from failing due to unexpected rate limiting.
Migrating an old system's data calls
A team maintains a legacy application that relies on XAPI syntax. Instead of rewriting their code, they instruct their agent to use execute_xapi, which processes the query and returns the required raw XML data.
The honest tradeoffs
Treating it like a simple database search
Asking for 'The list of all hospitals' without defining geography. The system can't know where to look.
You must always define the area first. Use execute_query and include a bounding box filter in your Overpass QL query. Don't just ask; give it coordinates.
Running big queries without checking limits
Launching 50 complex searches back-to-back, only to hit an API throttle error on the tenth request.
Always check capacity first. Start by calling get_status. If slots are low, break up your work into smaller batches of queries.
Assuming JSON is always enough
Expecting simple coordinates when the underlying data structure needs to be read for geometry or raw XML details.
If you need the full, unprocessed map layer, use get_map to pull the complete OSM XML. If you just need filtered points, stick with execute_query.
When It Fits, When It Doesn't
Use this Overpass MCP Server if your data problem is inherently geospatial. That means the relationship between locations (e.g., 'What buildings are within 50m of a river?') or the physical boundaries matter more than simple record lookups.
Do use it if: You need to query against OpenStreetMap's global dataset, you require raw XML map data (get_map), or you need to check API capacity (get_status).
Don't use it if: You are looking for simple record lookups (e.g., 'What is the employee ID?'). For those, a dedicated database connector tool is better. This server is only for querying map features and geography.
Questions you might have
How do I find all gas stations using execute_query? +
You use execute_query and write an Overpass QL query that targets the OSM tag for gas stations. Remember to include the necessary bounding box coordinates in your query parameters.
What is the difference between get_map and execute_query? +
execute_query returns filtered, structured data (e.g., just hospitals). get_map returns every single node, way, and relation in raw XML for a given area, regardless of what they are.
Should I run get_status before querying? +
Yeah, always check get_status. It tells you if your API slots are low or if there's an active rate limit cooldown. Running large jobs when slots are tight wastes time.
Can I use the Overpass MCP Server for non-geospatial data? +
No. This server is strictly for OpenStreetMap geometry and map features. If you need financial records or user profiles, you'll need a different database connector.
If my Overpass QL query fails using `execute_query`, how do I debug the syntax? +
The server response will include a specific error code and message pointing to the failure location. You need to check your syntax carefully against standard Overpass QL documentation for common pitfalls like misplaced parentheses or incorrect relation types.
When should I use `execute_xapi` instead of running a query with `execute_query`? +
Use execute_xapi only when you require the raw XML data output. For virtually all other tasks—especially those requiring easy parsing in an agent workflow—you should stick to execute_query because it guarantees JSON format.
Is there a limit to the size of the bounding box I can pass to `get_map`? +
While the API handles large areas, extremely massive boxes often cause timeouts. You should break down your target region into smaller, manageable segments and run multiple calls to get_map sequentially for reliable results.
After checking my status with `get_status`, what should I do if the slot availability is zero? +
If get_status reports no available slots, you must wait. Do not repeatedly send queries; monitor the API documentation for the specific cooldown period before attempting to run any tools again.
How do I find all restaurants in a specific city using this server? +
You can ask the agent to use the execute_query tool with an Overpass QL string, for example: [out:json];area[name='Berlin'];node(area)[amenity=restaurant];out;. The agent will handle the execution and present the results.
Can I download raw map data for a specific coordinate range? +
Yes. Use the get_map tool and provide the bounding box coordinates in the format min_lon,min_lat,max_lon,max_lat. This will return the raw OSM data for that area.
What should I do if the API returns a rate limit error? +
Run the get_status tool. It will show you how many slots are available and if there is a cooldown period active for your IP address.
We've already built the connector for Overpass. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 4 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.