Grafana k6 Cloud MCP. Analyze performance and audit SLOs directly in 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.
Grafana k6 Cloud (Load Testing) MCP Server lets you manage your entire performance testing lifecycle through natural conversation. You can list and retrieve details for all your load tests, start new test runs, and analyze detailed performance metrics (latency, error rates, throughput) for completed runs, all without jumping between dashboards.
It’s your AI agent's direct line to k6 Cloud infrastructure.
What your AI agents can do
Get run
Retrieves the full details for a specific k6 test run.
Get run metrics
Gets detailed performance metrics (latency, error rates, throughput, etc.) for a completed k6 run.
Get run thresholds
Fetches the evaluation results to verify if a k6 run met its set performance thresholds.
The agent retrieves names, IDs, and configurations for all available load tests and projects within your k6 Cloud account.
The agent starts a new test run on k6 Cloud infrastructure or immediately halts an active execution, controlling system resources.
The agent pulls aggregated performance data (latency, error rates, throughput) for a completed test run.
The agent retrieves detailed threshold evaluation results, verifying if the application met its predefined performance requirements.
The agent checks the status of ongoing test runs, reporting state transitions like QUEUED, RUNNING, or FINISHED.
Ask AI about this MCP
Supported MCP Clients
OAuth 2.0 Compatible Gemini Waiting for input…
Grafana k6 Cloud: 10 Tools for Performance Testing
Coordinate test runs, manage projects, and retrieve detailed performance metrics from your k6 Cloud account using these 10 specialized tools.
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 Grafana k6 Cloud (Load Testing) on Vinkius019d75beget run
Retrieves the full details for a specific k6 test run.
019d75beget run metrics
Gets detailed performance metrics (latency, error rates, throughput, etc.) for a completed k6 run.
019d75beget run thresholds
Fetches the evaluation results to verify if a k6 run met its set performance thresholds.
019d75beget test
Retrieves the full details for a specific k6 test configuration.
019d75belist organizations
Lists all organizations on k6 Cloud, providing names, IDs, and member counts.
019d75belist projects
Lists all projects within a specific k6 Cloud organization.
019d75belist runs
Lists test runs, showing IDs, status (QUEUED/RUNNING/FINISHED), VU counts, and timestamps.
019d75belist tests
Lists all load tests available on Grafana Cloud k6, showing names, IDs, and last run statuses.
019d75bestart test run
Initiates a new k6 Cloud test run and returns the new active run ID for tracking.
019d75bestop test run
Stops a currently running k6 Cloud test execution.
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 Grafana k6 Cloud (Load Testing), then connect any of our 4,800+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,800+ 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 Grafana k6 Cloud. 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.
Tracking load tests means clicking through five different dashboards.
Today, to check if a recent deployment broke the checkout flow, you navigate to the k6 Cloud dashboard. You find the 'Runs' tab, locate the right run ID, and then you have to click into the 'Metrics' tab, and often a third tab for 'Thresholds.' You copy the critical numbers—like P95 latency or the total failure count—and paste them into a Jira ticket or a Slack message. It's a lot of context switching, and you always lose a step.
With this MCP Server, you just talk to your agent. You say, 'What was the average latency for the last checkout run?' The agent handles the run ID lookup, the metric retrieval, and the formatting, giving you the single number you need right in your chat window. It cuts the process from 5 minutes of clicking to 5 seconds of talking.
Grafana k6 Cloud (Load Testing) MCP Server: Start and control runs.
Manual testing involves going to the k6 Cloud console, selecting the correct project, configuring the virtual users, and hitting the 'Run' button. Then, you have to keep refreshing the page to see if it's still running. If it's going wrong, you have to remember the run ID and manually navigate back to stop it.
Now, you tell your agent, 'Start a new test run for the API Stress Test.' The agent executes `start_test_run` and gives you the new run ID. If the test goes wild, you just tell it to `stop_test_run`. The whole lifecycle—from start to stop—is managed via a simple conversation. It’s immediate and auditable.
What you can do with this MCP connector
Man, you wanna take charge of your performance testing without jumping through hoops? This server gives your AI agent a direct line to k6 Cloud infrastructure. You'll manage your whole load testing lifecycle just by talking to your agent. You don't gotta switch between dashboards anymore.
Managing Your Tests and Projects
Your agent can list all the organizations you've got, giving you the names, IDs, and how many members are in each. It can also list every project inside a specific organization. When it comes to the tests themselves, your agent can list all the load tests available on Grafana Cloud k6, showing you their names, IDs, and the status of their last run.
You can also list all the test runs, seeing the IDs, current status (like QUEUED, RUNNING, or FINISHED), how many Virtual Users (VU) were used, and when they ran.
Running and Stopping Tests
If you need a new test, your agent can initiate a test run on k6 Cloud and spit out the new active run ID so you can track it. If a test's running too long or you gotta stop it, your agent can halt a currently running k6 Cloud test execution, saving you some resources.
Checking the Results
Once a test is done, your agent can pull the full details for a specific k6 test run. It can also grab detailed performance metrics—that means latency, error rates, and throughput—for a completed k6 run. You can get the full details for a specific k6 test configuration. Need to know if your app hit its targets? Your agent can fetch the evaluation results to verify if a k6 run met its set performance thresholds.
You can also check the status of test runs to see if they're QUEUED, RUNNING, or FINISHED.
This setup lets your AI agent handle everything from setting up the test to analyzing the final numbers, all without you ever leaving your chat window. It’s a complete control panel for k6 Cloud, straight into your workflow.
019d75be-f178-711d-bf25-88256f131864 
How Grafana k6 Cloud MCP Works
- 1 Subscribe to the server and provide your k6 Cloud API Token.
- 2 Your AI client connects to the MCP endpoint and asks for a test run status or metric.
- 3 The agent calls the appropriate tool (e.g.,
list_runsorget_run_metrics) and returns the structured data.
The bottom line is, your agent uses your API token to talk directly to k6 Cloud, letting you manage the entire performance testing process through simple conversation.
Who Is Grafana k6 Cloud MCP For?
The performance engineer who gets tired of clicking through 15 different tabs to find a single performance number. The DevOps SRE who needs to verify if a new deployment broke a critical SLO. Or the QA automation specialist who needs to audit test history across multiple environments quickly.
Triggers load tests, checks run metrics, and analyzes thresholds in one continuous chat session.
Monitors application thresholds after deployments and verifies performance regressions without logging into the console.
Audits the history of test runs across different environments and reports on overall system reliability efficiently.
What Changes When You Connect
- Analyze Metrics Instantly: Instead of digging through dashboards, use
get_run_metricsto pull aggregated data—average response time, P95 latency, error rates—for any completed run. You get the numbers immediately. - Verify SLO Compliance: Need to know if your app hit its performance targets?
get_run_thresholdspulls the detailed evaluation results. You confirm if your service meets specific SLOs against defined requirements. - Manage the Pipeline: Use
list_testsandlist_projectsto get a full inventory of every test and project in your account. It lets you know what tests exist before you even start building a run. - Control Resources: Start a test run with
start_test_runand, if things go sideways, usestop_test_runto kill it immediately. This prevents runaway tests from burning unnecessary k6 Cloud compute time. - Audit History: Use
list_runsto see a quick summary of all test executions—IDs, status (QUEUED/RUNNING/FINISHED), and duration—allowing you to track historical performance trends. - Deep Dive Debugging: If a run fails, you can use
get_runto get the full context and details of that specific execution, helping you pinpoint exactly where the failure happened.
Real-World Use Cases
The Post-Deployment Smoke Check
A developer pushes a new API endpoint. They ask their agent to 'Start a new test run for the Checkout Flow.' The agent uses start_test_run. After the run finishes, the developer immediately asks for 'the performance metrics for the last run.' The agent calls get_run_metrics, returning average latency and failure rates. The developer verifies the change didn't introduce regressions, solving the problem in minutes without touching a dashboard.
Auditing Service Reliability
The QA team needs to know if the payment gateway passed its compliance checks. They ask the agent to 'Check the threshold evaluation for the main transaction test.' The agent calls get_run_thresholds, confirming that the failure rate never exceeded the mandated 0.1%. The team gets verifiable proof of compliance, which is much faster than manual reporting.
Finding the Right Test Script
A new SRE joins the team and needs to know what load tests are available. They ask the agent to 'List all load tests in the Inventory service.' The agent calls list_tests and list_projects, giving the SRE a clear map of existing test assets and where they live, letting them get started instantly.
Quickly Triaging a Failure
A run fails and the team needs to figure out why. They ask the agent to 'Get the details for the run that failed 15 minutes ago.' The agent calls get_run using the run ID, providing the full execution context. This allows the team to quickly distinguish between a configuration error and an actual performance degradation.
The Tradeoffs
Checking metrics manually
Logging into k6 Cloud, finding the specific run ID, clicking on the metrics tab, then finding the specific graph for P95 latency. This takes 5-10 minutes and requires precise navigation.
→
Tell your agent to 'Show me the P95 latency for the last Checkout Flow run.' The agent executes get_run_metrics and gives you the number instantly. No clicking required.
Guessing the run ID
The team remembers a run happened, but they can't recall the exact run ID. They waste time searching through logs and status pages trying to match timestamps.
→
First, ask the agent to list_runs to get a list of recent run IDs and statuses. Then, tell it, 'Get the metrics for run ID [X].' You get the data you need without guessing.
Running tests without context
Just hitting 'Run Test' without confirming the current environment or required VUs. The test runs, but the results are useless because the scope was wrong.
→
First, use list_projects to confirm the correct project is selected. Then, tell the agent to 'Start a new test run for [Project Name].' The agent ensures the context is right before starting the test.
When It Fits, When It Doesn't
Use this MCP Server if your job requires coordinating multiple, distinct data points from k6 Cloud—specifically, when you need to execute a test, then check its metrics, and finally audit its thresholds. You need a single source of truth that links the test definition (get_test) to the run status (list_runs) and the performance outcome (get_run_metrics).
Don't use this if you only need to look at a single metric graph (e.g., just viewing the error rate on the k6 dashboard). For those simple views, the native k6 UI might be faster. But if you need to act on the data—like starting a run or checking compliance against a predefined SLO—this tool is necessary. If you need to manage assets across many accounts, start with list_organizations to map your scope.
Common Questions About Grafana k6 Cloud MCP
How do I list all my load tests using the list_tests tool? +
The agent calls list_tests and returns a list of all available load tests. This list includes the test name, its ID, and the status of its last run, helping you quickly map your entire test suite.
What is the difference between get_run_metrics and get_run_thresholds? +
Metrics show raw performance data—things like average response time, P95 latency, and total iterations. Thresholds check if that raw data met your required standard, telling you if you passed or failed the SLO.
Can I stop a running test using the stop_test_run tool? +
Yes. The agent calls stop_test_run and immediately sends the stop command to k6 Cloud. This is crucial for managing resources and preventing runaway tests from draining compute power.
Do I need to know the run ID to get_run_metrics? +
Yes. You must provide the specific run ID to get_run_metrics so the agent knows exactly which test execution's data you want to analyze.
How do I list all available organizations using the list_organizations tool? +
The list_organizations tool returns organization names, IDs, and member counts. You use this first to see which environments are available before managing tests.
What is the purpose of the `start_test_run` tool? +
The start_test_run tool initiates a new k6 Cloud test run and returns the active run ID. This ID lets you track the test's status and monitor its progress.
Can I check the status of a test run using the list_runs tool? +
Yes, list_runs returns run IDs, status states (QUEUED/RUNNING/FINISHED/ABORTED), VUs, durations, and timestamps. This helps you track the test's lifecycle at a glance.
How do I get detailed information about a specific test using the get_test tool? +
The get_test tool retrieves the full details of a specific k6 test, including its script and configuration. You can use this to audit the test setup before running it.
Can I see if a load test passed its performance thresholds using my agent? +
Yes. Use the get_run_thresholds tool with a specific Run ID. Your agent will retrieve the final evaluation for all defined thresholds in the script, indicating which specific SLOs passed or failed.
How do I start a new k6 Cloud test run through a conversation? +
Use the start_test_run tool by providing the Test ID. Your agent will trigger the execution on k6 Cloud infrastructure and return an active Run ID that you can use to track real-time progress.
Can my agent retrieve the raw performance metrics for a completed run? +
Absolutely. The get_run_metrics tool allows your agent to aggregate data like http_req_duration, error counts, and total iterations, providing a rapid summary of your application's behavior under load.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.