OpenCage MCP for AI. Convert Addresses to Coordinates & Back.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
OpenCage handles geocoding and reverse geocoding for your AI agent. You can convert any address to precise latitude/longitude coordinates, or turn GPS pins back into structured street addresses.
The service offers filters like country restrictions, confidence scoring (1-10), and privacy modes for sensitive data.
What your AI can do
Geocode basic
Performs a general geocoding lookup within the OpenCage Engine boundaries.
Geocode bounding box
Restricts searches to a specific geographic rectangle (polygon) to pinpoint locations in a defined area.
Geocode high confidence
Runs an automated check that requires explicit score limits, returning highly validated location data.
The agent takes an address string (e.g., '123 Main St') and returns the corresponding latitude/longitude coordinates.
Given a lat/lng coordinate pair, the agent converts it into a readable street address format.
The system narrows down results using constraints like specific countries or bounding boxes to eliminate ambiguous matches.
You filter output by a minimum confidence level (1-10) to ensure the returned coordinates are accurate enough for production use.
The agent runs location lookups without OpenCage logging the query, protecting sensitive addresses in compliance with privacy requirements.
Ask an AI about this
Waiting for input…
OpenCage MCP Server: 10 Tools for Location Data Processing
These tools allow your AI agent to perform advanced geocoding (address to coordinates) and reverse lookups (coordinates to address), with deep filtering capabilities.
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 OpenCage on VinkiusGeocode Basic
Performs a general geocoding lookup within the OpenCage Engine boundaries.
Geocode Bounding Box
Restricts searches to a specific geographic rectangle (polygon) to pinpoint...
Geocode High Confidence
Runs an automated check that requires explicit score limits, returning highly...
Geocode Country Filter
Filters results by country code, ensuring the address match belongs only to that...
Geocode Language Bias
Retrieves results localized in a specific language code (e.g., pt-BR) for...
Geocode All Duplicate Results
Retrieves structural matches confirming multiple delivery alternatives for an address.
Geocode No Record Privacy
Generates secure mappings for geocoding queries without storing them in OpenCage's logs.
Reverse Basic
Lists structured rules to export active GPS pin data into a readable address format.
Reverse Fetch Time Annotations
Extracts UTC logic from GPS pins, providing historical validation limits like...
Reverse Fast No Annotations
Quickly identifies accurate location arrays spanning native boundaries for fast...
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 OpenCage 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 OpenCage, 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 OpenCage. 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
Works with 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 10 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Manually validating addresses is slow, error-prone work.
Right now, every time you get an address—whether from a web form or a spreadsheet—you have to manually cross-reference it. You might check if the zip code matches the state, then look up the city name against a separate database, and finally verify that the combination exists in your CRM. It's tedious copy/pasting across five different tabs.
With OpenCage, you just give your agent the address string. The agent runs the geocoding function and spits out a single, clean JSON object containing coordinates, confidence scores, and structured metadata. You get validated data instantly—no tabs needed.
OpenCage MCP Server: Reliable Coordinates from Any Address.
Previously, if you ran a basic lookup, you got coordinates, but you lost the context. You might not know which country the address belonged to, or if that coordinate was accurate enough for actual delivery. The data felt incomplete.
Now, running `geocode_country_filter` ensures the result is limited by the correct ISO code, and using confidence scoring means you only act on coordinates proven reliable. It's structured, filtered, and ready to use.
What your AI can actually do with this
When your agent needs to figure out a location, OpenCage handles both ends of the street: converting a raw address string into precise coordinates, or taking a GPS pin and turning it back into a readable street address. You'll use these tools by calling them directly from your AI client.
Forward Geocoding (Address to Coordinates)
When you start with an address—say, '123 Main St'—you run the core lookup using geocode_basic for a general search within OpenCage boundaries. If that initial result is ambiguous or if you need confirmation on multiple delivery points, use geocode_all_duplicate_results; it retrieves structural matches confirming those alternative options. You don't wanna guess; you gotta be precise.
To make sure your location data is trustworthy enough for production, you can run the search with strict validation using geocode_high_confidence. This tool requires you to set explicit score limits (1–10), guaranteeing that the coordinates returned are highly validated. If you're working internationally, you don't want generic results; use geocode_language_bias to get results localized in a specific language code, like pt-BR, which handles tricky international address formats.
You can also narrow down your search dramatically using filters. To keep the location confined, employ geocode_bounding_box, which restricts searches to a precise geographic rectangle (a polygon). If you only care about one country, use geocode_country_filter and pass the specific two-letter code; this guarantees the address match belongs only to that nation.
When privacy is your biggest concern, forget logging anything down. You run location lookups without OpenCage ever recording the query by calling geocode_no_record_privacy.
Reverse Geocoding (Coordinates to Address)
If you've got a raw latitude/longitude pair—a GPS pin—and need to know what street it belongs to, start with reverse_basic. This lists structured rules that export active GPS data into an easily readable address format. For quick lookups where you just need the location array and don't want extra details slowing things down, use reverse_fast_no_annotations; this identifies accurate location arrays spanning native boundaries fast.
If you need more than just the street name from a pin, you can pull in time data. The reverse_fetch_time_annotations tool extracts UTC logic from GPS pins. That gives you historical validation limits like sunrise and sunset times for that exact spot.
Overall, your agent handles these tasks by converting addresses to coordinates or vice versa, while letting you restrict the results using filters for country code, bounding boxes, confidence scores, or language bias.
019d75e8-e057-720c-9de4-b4f217c46779 
Here's how it actually works
The bottom line is: it turns raw text or raw GPS points into reliable, usable geospatial data that your application can act on.
First, you subscribe to this server and provide your unique OpenCage API Key.
Next, you tell your AI client (Claude, Cursor, etc.) what location task you need done—like 'Find coordinates for 1600 Amphitheatre Parkway'.
The agent calls the appropriate geocoding tool. You get back structured JSON containing coordinates, confidence scores, and formatted addresses.
Who is this actually for?
Anyone dealing with location data in production. This is for the logistics manager who needs to validate thousands of delivery addresses before dispatching a single driver. It's for the data engineer building pipelines that need to enrich raw CSV files with accurate coordinates and timezone info, or the app developer handling user input where privacy means everything.
Validates delivery addresses against real-world maps before scheduling routes. This prevents failed deliveries because of bad inputs.
Enriches large, unmapped datasets by running batch geocoding to add lat/lng and timezone metadata for later analysis.
Handles user location input where data logging is restricted. They use the Privacy Mode tools to process locations without creating a trail in third-party logs.
What Changes When You Connect
Avoid ambiguous location matches. Using geocode_country_filter forces results into a specific country, so you don't end up with misplaced addresses from another region.
Improve data quality by enforcing minimum standards. The geocode_high_confidence tool runs an automated check that limits results to only the most reliable coordinates (score 1-10).
Handle sensitive user input safely. When running lookups for private addresses, use geocode_no_record_privacy. OpenCage won't log the query, keeping your data secure.
Speed up simple lookups. If you just need a coordinate fast and don't care about extra details, use reverse_fast_no_annotations to get results quickly.
Structure complex searches. Need to find an address within a specific neighborhood? Use geocode_bounding_box to constrain the search area precisely.
See it in action
Validating Delivery Routes
A logistics team needs to confirm if '123 Main St, Miami' is a valid delivery point. They ask their agent to run geocode_high_confidence and filter by country (US). The tool returns coordinates with 9/10 confidence, confirming the address for dispatch.
Building Global Address Books
A data engineer is building an international dataset. They ask their agent to geocode 'Av. Paulista' but need results localized in Portuguese (pt-BR). The agent uses geocode_language_bias to ensure the address format and metadata are correct for Brazil.
Analyzing GPS Data Points
A developer gets a raw list of GPS coordinates from user tracking. They ask their agent to run reverse_fetch_time_annotations. The result doesn't just give the address; it also provides the UTC logic for local sunrise and sunset times, adding value.
Bounding Search Area
A business needs coordinates for a specific commercial park defined by four corners. Instead of guessing an address, they ask their agent to use geocode_bounding_box. This tool constrains the search to that precise rectangular area.
The honest tradeoffs
Using general lookups for sensitive data
The developer just calls geocode_basic on a user's home address. The system logs the query, violating company privacy policy.
Don't use basic geocoding. For private addresses, always call geocode_no_record_privacy. This runs the lookup without leaving any trace in OpenCage's log files.
Ignoring location confidence
The agent returns a coordinate pair from reverse_basic and uses it immediately, even though the result is low quality or ambiguous.
Never trust raw coordinates. Always run a validation check using geocode_high_confidence. This forces the system to verify the data against strict score limits first.
Over-relying on basic reverse lookups
The developer uses reverse_basic because it's simple, but they lose crucial metadata like timezones or formatted addresses.
If you need more than just the address name, use a specialized tool. Check geocode_bounding_box for spatial constraints, or reverse_fetch_time_annotations to get date/time logic.
When It Fits, When It Doesn't
Use this server if your primary job involves translating location data—whether that's turning text into coordinates, or vice versa. You need OpenCage when the accuracy of a coordinate pair determines success (e.g., logistics, routing).
Use geocode_basic: When you just need a quick estimate and speed is more important than perfect validation.
Use specialized tools like geocode_bounding_box, geocode_high_confidence, or geocode_country_filter: When precision matters. If the result needs to be 'delivery grade,' use these constraints. They force accuracy by limiting possible outcomes, which is critical for financial or physical operations.
Don't use this if: You only need general map visualization (use a dedicated mapping service) or if your location data is already structured and validated within your own database schema.
Questions you might have
How do I prevent OpenCage from logging my private addresses using geocode_no_record_privacy? +
You simply call the geocode_no_record_privacy tool. This ensures that while your agent performs the lookup, the query is processed without being stored in OpenCage's logs, protecting sensitive user data.
Should I use geocode_basic or geocode_high_confidence? +
For production code where accuracy matters, always prefer geocode_high_confidence. It runs an automated validation check that requires specific score limits, guaranteeing a much higher level of confidence than the basic lookup.
Can I filter results to only show US addresses using geocode_country_filter? +
Yes. You use geocode_country_filter and pass the ISO 3166-1 Alpha-2 code 'US' (or any other country). This restricts all possible matches to that specific nation.
How is reverse geocoding different from just calling a basic lookup? +
A standard lookup takes text and gives coordinates. Reverse geocoding, using reverse_basic, does the opposite: it takes raw GPS coordinates (lat/lng) and converts them back into a formatted street address.
What is the benefit of using reverse_fetch_time_annotations? +
This tool goes beyond just listing an address. It extracts 'UTC logic' from the location pin, giving you crucial metadata like today's sunrise and sunset times for that specific coordinate.
If I need the fastest possible coordinates lookup, should I use `reverse_basic` or `reverse_fast_no_annotations`? +
Use reverse_fast_no_annotations. It skips generating extra data like sunrise/sunset times and just provides the core location arrays. This cut significantly reduces payload size and improves response speed.
When I use `geocode_bounding_box`, what defines the search area? Is it a simple rectangle? +
No, you define a specific polygon for the search area. This lets you constrain results to non-rectangular regions, which is essential when your target zone has irregular borders or specialized boundaries.
If I run an address through `geocode_basic` and get multiple potential matches, how do I decide on the right one? +
The service provides a confidence score for each result. You can filter these results by setting a minimum required confidence level (e.g., >= 8) so your agent only acts on highly certain data.
How accurate is the geocoding — can I use it for delivery routing? +
OpenCage returns a confidence score from 1 to 10 for each result. Use the high-confidence filter (min_confidence=8 or higher) to get delivery-grade accuracy. Combined with country filtering, you can eliminate ambiguous matches and get coordinates reliable enough for last-mile dispatch.
What does privacy mode actually do? +
When you enable no_record=1, OpenCage processes your query but doesn't log it in their cache or analytics. The result is identical, but the query leaves no trace on their servers. Ideal for geocoding patient addresses, legal documents, or any PII-sensitive data.
Can I geocode in multiple languages — like getting results in Portuguese for a Brazilian address? +
Yes. Use the language bias tool with any IETF language code (pt-BR, es-MX, fr-FR, etc.) and OpenCage returns the address components translated to that locale. Perfect for building multilingual apps or standardizing address formats across regions.
We've already built the connector for OpenCage. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 10 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.