Dune Analytics MCP for AI. Run complex SQL queries on blockchain data.
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
Dune Analytics Web3 SQL Analytics API lets your agent run complex SQL queries against live, historical data from major blockchains like Ethereum, Solana, and Polygon.
You execute queries via natural conversation, track their status, retrieve the raw results, or cancel them if they take too long.
What your AI can do
Cancel execution
Stops an ongoing query job immediately using its unique execution ID.
Execute query
Starts a new data analysis job by running a specific Dune query ID with optional parameters, returning a trackable ID.
Get execution results
Retrieves the full set of data rows from an execution that has already finished successfully.
Start an execution job by providing a specific Dune query ID along with any required parameters.
Check the current state of any running or queued query, seeing if it's pending, complete, or failed.
Pull the full set of data rows from a completed query execution for immediate analysis.
Cancel any ongoing or unnecessary query job to save API credits and clean up resources.
Ask an AI about this
Waiting for input…
Dune Analytics (Web3 SQL Analytics API) with 4 Tools
These four tools let your agent manage the entire lifecycle of a blockchain query: starting it, monitoring its progress, pulling the final data, or stopping it early.
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 Dune Analytics (Web3 SQL Analytics API) on VinkiusCancel Execution
Stops an ongoing query job immediately using its unique execution ID.
Execute Query
Starts a new data analysis job by running a specific Dune query ID with optional...
Get Execution Results
Retrieves the full set of data rows from an execution that has already finished...
Get Execution Status
Checks and reports the current state (pending, complete, or failed) of a running...
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.
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 Dune Analytics (Web3 SQL Analytics API), 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
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 4 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
The Pain of Manual Blockchain Data Aggregation
Today, getting comprehensive Web3 metrics means jumping through hoops. You open Dune Analytics in one tab for ETH data, another dashboard for Solana stats, and then you copy-paste the key figures into a spreadsheet just to compare them. Then, if your query fails or times out, you have to manually re-run it and hope you didn't lose any work.
With this MCP, that friction disappears. You simply tell your agent what metrics you need—like 'Show me the total value locked in Polygon DeFi last week.' The agent runs the complex SQL job for you, waits until it finishes, and delivers a clean, usable data table right where you are working.
Get Data with Dune Analytics (Web3 SQL Analytics API) MCP
The process of running complex queries used to require knowing the exact query IDs, managing multiple status checks across different tools, and manually handling failure states. It was a multi-step technical chore.
Now you just talk to your agent. The entire workflow—from initiating the job with `execute_query` to confirming completion via `get_execution_status` and finally retrieving data using `get_execution_results`—happens automatically in the background, giving you clean, actionable insights instantly.
What your AI can actually do with this
Need to analyze on-chain metrics without opening a browser? This MCP connects your agent directly to Dune Analytics, letting you query massive blockchain datasets using SQL right from your preferred AI client. You don't have to build custom connectors for every chain; just talk to it and get the data.
Your agent handles everything: running complex queries, waiting for results, fetching the final tables, and even killing a runaway job if needed. Because this connection is hosted on Vinkius, you connect once from your AI client and gain access to all of its capabilities. This means deep crypto research or financial analysis becomes a simple conversation.
019e5d14-3cdb-72b9-9d1f-3bd1a7009b62 Here's how it actually works
The bottom line is, you initiate an asynchronous process, track its state, and then grab the resulting data without manually managing any web dashboard.
You tell your agent which Dune query you want to run, providing the necessary ID and parameters.
The system starts the execution and gives you a unique ID that tracks the job's progress.
Your agent monitors this status using the ID until it reports 'COMPLETED,' at which point it retrieves the full dataset.
Who is this actually for?
Crypto researchers who spend hours clicking through dashboards. Data analysts who need DeFi or NFT metrics instantly. Web3 developers verifying on-chain contract behavior directly from their code editor.
Pulls the latest DeFi, NFT, or DAO metrics by telling the agent to run a specific query ID and then formatting the results for a report.
Verifies on-chain states, contract interactions, or protocol health directly from their IDE using the agent's ability to execute queries.
Automates gathering market trend data and ecosystem growth metrics by running multiple related queries and summarizing the outputs for a report.
What Changes When You Connect
Stop leaving your workspace. You get to pull the latest DeFi, NFT, or DAO metrics without ever needing to open a separate dashboard.
Manage time and credits by using the cancel_execution tool. If a query stalls, you can stop it instantly instead of waiting minutes for nothing.
Get data right when you need it. The agent first uses execute_query, then polls with get_execution_status, ensuring you only retrieve results when they are actually ready.
Deep dive into multiple chains. This MCP covers Ethereum, Solana, Polygon, and more, meaning one connection handles all your Web3 data needs.
Analyze raw tables immediately. Once the job is done, get_execution_results pulls the entire dataset directly to your agent for visualization or scripting.
See it in action
Tracking Whale Movements
A researcher wants to know which wallets moved the most ETH last week. They ask their agent, and it uses execute_query with specific parameters for the date range. The agent then waits using get_execution_status until the data is ready, finally calling get_execution_results so they can summarize the top holders.
Checking Protocol Health
A developer needs to verify if a specific DeFi protocol's liquidity pool is reporting zero value. They ask their agent to run a predefined query ID and use get_execution_status repeatedly until the data returns, confirming the current on-chain state.
Running Multi-Step Reports
A financial analyst needs three different metrics (NFT volume, DAO treasury size, gas fee trends). They ask their agent to run these three separate queries sequentially and use get_execution_results for each one, compiling a single report in the chat window.
Killing Stale Jobs
An analyst accidentally runs an extremely broad query that hangs. Instead of waiting forever, they tell their agent to use cancel_execution, immediately freeing up resources and allowing them to re-run a more targeted job.
The honest tradeoffs
Polling too fast
Asking the AI agent to check the status repeatedly every second. This hammers the API, wastes credits, and often hits rate limits.
The right way is to let your agent manage the state machine: use execute_query first, then rely on the agent's internal logic to poll using get_execution_status at appropriate intervals until completion.
Ignoring job IDs
Telling the agent 'Check the status of my query.' The system has no way to know which specific, running query you mean.
Always use the unique ID provided by execute_query when calling get_execution_status. This guarantees your request targets the correct job.
Assuming instant results
Asking for data and immediately expecting a result. Since blockchain queries are complex, they take time.
You must always check the status first. Use get_execution_status to confirm the job is 'COMPLETED' before attempting to use get_execution_results.
When It Fits, When It Doesn't
Use this MCP if your work revolves around pulling structured, historical data from major blockchains (Ethereum, Solana, Polygon) and you need to manage that process via conversation. The core workflow requires understanding asynchronous state: initiate the job, track its status, then retrieve the results. Don't use it if you just need simple text lookups or real-time live feed monitoring; this is for batch analytics on established datasets. If your goal is purely conceptual discussion about crypto trends without data backing, use a general knowledge agent instead. But when the prompt demands 'show me the numbers,' this MCP is essential.
Questions you might have
How do I retrieve the actual data rows from a query? +
First, use execute_query to start the process and get an execution_id. Once get_execution_status shows the state is completed, use get_execution_results with that ID to fetch the data.
Can I stop a query that is taking too long to run? +
Yes. You can use the cancel_execution tool by providing the active execution_id. This will immediately interrupt the ongoing query on Dune's servers.
How do I pass parameters like dates or addresses to my Dune query? +
When calling execute_query, use the query_parameters field. It accepts a JSON string (e.g., '{"address": "0x...", "limit": 10}'). The agent will parse this and apply it to your SQL execution.
How do I authenticate my Dune Analytics account before running an `execute_query`? +
You must set up your connection using a valid Dune API Key. This key authorizes your AI client to run queries and tracks all usage against your personal quota.
What should I do if the `get_execution_status` reports that my query has failed? +
A 'FAILED' status means Dune encountered an error, often due to incorrect SQL syntax or resource limits. You need to inspect the returned logs and adjust your query before retrying.
Is there a limit to how frequently I can use `execute_query`? +
Yes, Dune enforces API rate limits and quota restrictions based on your plan type. Always check your usage dashboard within the Vinkius Marketplace to prevent service interruptions.
When should I call `get_execution_status` before attempting to use `get_execution_results`? +
You must verify the status first. Calling get_execution_status ensures the query has reached 'COMPLETED' before your agent attempts to retrieve data via get_execution_results.
How does the API handle massive amounts of data retrieved by `get_execution_results`? +
The MCP is built to manage large result sets, but you should process them in chunks or stream them through your agent. Loading millions of rows at once can overwhelm local memory.
We've already built the connector for Dune Analytics. 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.
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.