CARTO MCP. Run complex spatial SQL and location analysis via chat.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
CARTO MCP Server connects your AI agent to cloud-native spatial analytics. Use it to run explicit SQL queries (BigQuery, Snowflake, Redshift), batch-geocode addresses, calculate optimal routes, and generate service area isolines.
It lets you map, slice spatial boundaries, and script complex data operations without opening the CARTO GIS interface.
What your AI agents can do
Calculate isoline
Generates a GeoJSON polygon showing the area reachable from a point within a specified travel time or distance.
Calculate route
Returns the optimal driving route geometry, total distance, and duration between two specified points.
Create async sql job
Submits a large SQL query to run in the background, which is necessary for heavy geospatial analytics that take longer than one minute.
Executes arbitrary SQL queries against your connected data warehouse (BigQuery, Snowflake, Redshift, etc.) for quick analysis or large batch jobs.
Converts large lists of raw street addresses into accurate latitude/longitude coordinates in a single request.
Generates polygons that define the area reachable from a center point within a specified travel time or distance.
Determines the shortest, quickest path between two points, returning the route geometry, total distance, and duration.
Imports external files (CSV, GeoJSON, Shapefile, KML) from a URL and loads them into a new managed table in your data warehouse.
Retrieves metadata about all existing data layers and visualization assets in your CARTO organization.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
019d7569calculate isoline
Generates a GeoJSON polygon showing the area reachable from a point within a specified travel time or distance.
019d7569calculate route
Returns the optimal driving route geometry, total distance, and duration between two specified points.
019d7569create async sql job
Submits a large SQL query to run in the background, which is necessary for heavy geospatial analytics that take longer than one minute.
019d7569execute sql query
Runs a quick SQL query against your data warehouse, returning results as JSON rows within a one-minute limit.
019d7569geocode address
Converts a single street address string into precise latitude and longitude coordinates.
019d7569geocode batch addresses
Converts a large list of multiple street addresses into coordinates in a single, efficient batch operation.
019d7569get import status
Checks the progress and status of a previously started data import job.
019d7569import external file
Imports external files (CSV, GeoJSON, Shapefile, KML) from a public URL into a managed table.
019d7569list map datasets
Lists all available data layers and visualization assets within your CARTO organization.
019d7569poll async job status
Checks the completion status of a background SQL job that was previously submitted.
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 CARTO, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ 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
What you can do with this MCP connector
You connect your AI agent straight into CARTO for cloud-native spatial analytics. You run complex geospatial jobs and data operations without ever opening the CARTO GIS interface. This server gives your agent direct access to your data warehouse and CARTO's Location Data Services (LDS).
Running SQL Queries
Your agent can run quick SQL queries against your data warehouse using execute_sql_query, and it can submit big, heavy SQL jobs to run in the background using create_async_sql_job.
Processing Locations
Need to convert addresses to coordinates? Use geocode_address to turn a single street address string into precise latitude and longitude. If you've got a whole list of addresses, geocode_batch_addresses handles that in one go.
Mapping and Routing
Want to figure out the best way to get from Point A to Point B? calculate_route returns the optimal driving route geometry, plus the total distance and time. If you need to map out the area reachable from one spot—say, a service zone—you use calculate_isoline to generate a GeoJSON polygon based on time or distance.
Managing Data
Your agent can list all the data layers and visualization assets in your CARTO organization by calling list_map_datasets. To bring in outside data, it uses import_external_file to pull in files (CSV, GeoJSON, Shapefile, KML) from a public URL and load them into a managed table. You can also check the status of any background jobs with get_import_status or poll_async_job_status.
How CARTO MCP Works
- 1 Subscribe to the CARTO MCP Server and provide your active CARTO Organization and API Key.
- 2 Ask your AI agent to perform a spatial task (e.g., 'Find the 15-minute drive time around this point').
- 3 The agent uses the tool to interact with CARTO's API, running the job and returning the results (e.g., a GeoJSON polygon or a list of coordinates).
The bottom line is that your AI client runs the complex geospatial logic on CARTO's backend, and you just get the resulting data.
Who Is CARTO MCP For?
GIS Analysts, Data Scientists, and Logistics Strategists need this. They need to run complex, large-scale location analyses—like calculating service areas or finding optimal delivery routes—without needing to open the CARTO web UI or write boilerplate API code. It lets them focus on the data questions, not the plumbing.
Runs quick spatial joins or bulk-geocodes customer coordinates from a conversational terminal.
Asks the agent to calculate 15-minute delivery isolines and cross-reference them with population layers using SQL.
Triggers raw data imports and handles heavy dataset syncs for spatial tables, bypassing the graphical workspace.
What Changes When You Connect
- Calculate service areas and optimal routes instantly. Use
calculate_isolineto define 15-minute delivery zones orcalculate_routefor the fastest path between two points. - Handle massive datasets without breaking the UI.
create_async_sql_jobruns heavy, multi-join queries in the background, keeping your workflow smooth. - Process thousands of addresses at once.
geocode_batch_addressestakes a list of raw addresses and spits out coordinates, saving you from running 10,000 individual lookups. - Bring external data into your workflow.
import_external_filereads CSVs or GeoJSONs from a URL and makes them usable for spatial queries. - Keep track of everything. Use
get_import_statusandpoll_async_job_statusto know exactly when a long-running data job is finished or failed.
Real-World Use Cases
Optimizing Delivery Zones
A logistics manager needs to know which neighborhoods are within a 15-minute drive of a new store location. Instead of manual mapping, they ask their agent to 'Calculate a 15-minute drive-time isoline.' The agent runs calculate_isoline, providing the exact boundary geometry needed for site selection.
Bulk Customer Data Clean-up
A data scientist receives a CSV with 5,000 customer addresses that need coordinates. They feed the list to their agent, asking it to 'Batch geocode these addresses.' The agent uses geocode_batch_addresses, returning a clean list of lat/lon pairs ready for SQL analysis.
Running a Massive Data Sync
A data engineer needs to run a complex ETL job that joins 12 tables and refreshes a materialized view. They use create_async_sql_job to submit the query, then use poll_async_job_status to wait for confirmation, avoiding a synchronous timeout.
Analyzing Market Coverage
A retail strategist wants to know which population centers fall within the service area of existing stores. They use list_map_datasets to confirm the population layer exists, then instruct the agent to use execute_sql_query to perform a spatial join between the store locations and the population data.
The Tradeoffs
Geocoding individual addresses
Trying to run geocode_address 500 times on a list of 500 addresses. This is slow, inefficient, and burns through your API credits.
→
Use geocode_batch_addresses. Feed the entire list of 500 addresses to this single tool call. It processes the whole batch efficiently and returns all coordinates at once.
Hitting the SQL timeout limit
Running a complex, multi-join query in execute_sql_query that takes 70 seconds. The connection times out, and you lose the results.
→
If the query takes longer than a minute, you must use create_async_sql_job. Submit the query and then use poll_async_job_status to monitor it until completion.
Forgetting to check data status
Importing a large GeoJSON file using import_external_file and assuming it's ready for queries immediately. You just get an ID and nothing else.
→
After running import_external_file, you must check the status using get_import_status until it reports 'complete' before attempting to run any queries on the new data.
When It Fits, When It Doesn't
Use this server if your job involves location geometry, large-scale data joins, or address lookups. It handles the full cycle: data ingestion (import_external_file), data cleaning (geocode_batch_addresses), core calculation (calculate_isoline, calculate_route), and heavy processing management (create_async_sql_job).
Don't use it if you just need to view a single map layer or if your data analysis is purely text-based and doesn't involve location data. If your requirement is simple filtering on existing tables, execute_sql_query is enough. But if you're touching addresses, calculating paths, or doing big data syncs, you need the full suite.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by CARTO. 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 server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Manually prepping geospatial data is a nightmare.
Today, if you get a spreadsheet of addresses, you have to open a dedicated geocoding service, copy and paste the first 100 rows, wait for them to process, then copy the results into a new sheet. Then, if you have 5,000 addresses, you repeat that whole process, praying the service doesn't time out on you. It's tedious copy-pasting and fragile.
With the CARTO MCP Server, you just hand the whole list to your agent. It calls `geocode_batch_addresses` and gets a clean, structured output of thousands of lat/lon pairs, ready to drop right into your next analysis step. It handles the scale and the plumbing.
CARTO MCP Server: Run complex spatial calculations from chat.
You no longer need to jump between the SQL interface, the API playground, and the data uploader. You can tell your agent, 'Find the optimal routes and then run a query on the results.' The agent calls `calculate_route`, gets the geometry, and then uses `execute_sql_query` on it, all in one flow.
The whole process runs conversationally. The difference is that the server executes the entire complex workflow—the data prep, the calculation, and the query—without you having to manage a dozen API calls.
Common Questions About CARTO MCP
How do I use the `geocode_batch_addresses` tool? +
You provide the tool with a list of addresses (e.g., '123 Main St, Anytown'). The tool returns an array of structured results, including the latitude and longitude for each address in the list.
Is `execute_sql_query` the same as `create_async_sql_job`? +
No. execute_sql_query is for quick, synchronous reads (under 60 seconds). Use create_async_sql_job for anything big, like refreshing a materialized view or running a massive join, because it runs in the background.
What is the best way to find a service area? +
Use the calculate_isoline tool. You give it a center point and a time/distance parameter, and it generates a GeoJSON polygon showing the entire reachable zone.
How do I get data into the system? +
Use import_external_file. You provide a publicly accessible URL for your CSV, GeoJSON, or Shapefile, and the tool loads it into a new table for analysis.
What if my job fails? Can I check the status? +
Yes. Use poll_async_job_status to check the status of any background job (like those created by create_async_sql_job). It tells you if the job is 'running', 'done', or 'failed'.
How do I manage large data imports using `import_external_file`? +
The import_external_file tool returns an import_id you must track. Use get_import_status to poll the job until the state shows 'complete'. This manages large files like CSVs, GeoJSON, or Shapefiles.
What's the difference between `execute_sql_query` and `create_async_sql_job`? +
Use execute_sql_query for quick reads or simple queries that finish in under a minute. If your query takes longer than 60 seconds, you must use create_async_sql_job instead; it handles long-running batch transformations.
How do I check the status of an asynchronous job using `poll_async_job_status`? +
You poll this tool periodically (every 5-10 seconds) with the job ID. The response tells you the current state—whether it's 'pending', 'running', 'done', or 'failed'—and includes any error details.
Can my AI agent orchestrate heavy spatial analytics on large datasets directly? +
Yes. While small checks use the immediate SQL endpoint, your agent knows how to use the async Job API to submit massive postGIS or BigQuery geospatial operations on millions of rows. It automatically polls the remote status and notifies you once your heavy data transformation is structurally completed.
Am I able to geocode raw customer addresses in bulk through the agent? +
Definitely. Give your agent a list of unstructured addresses and it will fire the bulk geocode_batch_addresses tool. CARTO’s native LDS engine (powered by TomTom/HERE) returns the validated geo-coordinates for each row, avoiding manual CSV matching.
Can the agent create travel-time polygons (Isolines)? +
Absolutely. The agent uses the calculate_isoline tool passing the desired travel duration and coordinate center. It immediately receives a precise GeoJSON polygon defining the catchment zone or service area, without requiring you to use the map UI.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Hasura (Instant GraphQL & REST Engine)
Instantly connect to your Hasura engine to execute GraphQL queries, manage metadata, analyze SQL execution plans, and monitor server health.
Supabase
Connect your AI to Supabase. Execute database queries, manage users, and trigger PostgreSQL functions directly from your terminal.
Neon
Manage serverless PostgreSQL databases via Neon — provision projects, branches, endpoints and roles from any AI agent.
You might also like
Wati
Send WhatsApp template and session messages, and manage contacts on Wati — the leading WhatsApp Business API solution.
HigherGov
Find and track government contracts, grants, and procurement opportunities with intelligence built for public sector vendors.
UUID Generator API
Generate unique identifiers — audit UUIDs and versions via AI.