# Cypress Cloud MCP MCP > Cypress Cloud MCP connects your end-to-end testing platform directly to your AI agent. You can monitor test runs, inspect failed specs for screenshots and error logs, track intermittent failures, or generate detailed performance reports—all without leaving your development environment. ## Overview - **Category:** loved-by-devs - **Price:** Free - **Tags:** e2e-testing, test-automation, quality-assurance, debugging, test-reporting, ci-cd-pipeline ## Description This connection gives you total control over your quality assurance lifecycle using plain conversation. Instead of navigating through Cypress Cloud dashboards to find a specific failure log, you just ask your AI client about it. You can request a list of recent runs and get immediate status summaries, or dive deep into one failing test case to pull up the video and screenshot evidence right away. It's also useful for finding performance bottlenecks; you can generate slow test reports to check average duration metrics across your CI/CD pipeline. Furthermore, if you need an audit trail of intermittent bugs, the MCP identifies flaky tests and tracks their last failure dates. Because Vinkius handles all data flow through a zero-trust proxy, your credentials never sit on disk, keeping everything secure while letting your agent chain this test data with other services in your workflow. ## Tools ### get_instance Retrieves full details on one specific spec file execution, including videos, screenshots, and error messages. ### get_instances Lists all individual spec files run within a single test job, showing their status and duration. ### get_run Gets comprehensive details for one entire test run, including total tests, passes/fails counts, and commit info. ### get_runs Lists recent test runs for a project, providing status, duration, and build IDs to track history. ### get_tests Lists every individual test within an instance, returning titles, states (pass/fail), durations, and error messages. ### list_projects Finds all projects under your account to get the unique ID needed for subsequent data extraction. ### report_flaky Generates a report focused on intermittent failures, listing tests that frequently pass and fail. ### report_runs Creates an aggregated summary report of test runs for a specific date range, useful for BI dashboards. ### report_slow Generates a dedicated report showing the slowest tests based on average and p95 duration metrics. ### report_tests Pulls an enterprise-level report containing individual test data, statuses, and error messages across many runs. ## Prompt Examples **Prompt:** ``` List the last 5 test runs for project 'abc123' ``` **Response:** ``` I found 5 recent runs for project 'abc123'. The latest run (ID: 101) finished with status 'Passed' on the 'main' branch. Run 99 failed with 2 failing specs. Would you like to see the details for the failed run? ``` **Prompt:** ``` Show me why instance 'ins_789' failed ``` **Response:** ``` Retrieving details for instance 'ins_789'... It failed during 'Login spec'. Error: 'Timed out retrying after 4000ms: Expected to find element: .login-success, but never found it.' I have the video and screenshot links available. ``` **Prompt:** ``` Give me a report of flaky tests starting from 2024-01-01 ``` **Response:** ``` Analyzing flaky tests since Jan 1st... I identified 3 flaky tests. 'Checkout flow' has a 15% flake rate, and 'User profile update' has flaked twice this month. I can list the last flake dates for these. ``` ## Capabilities ### List Project IDs Find the unique 6-character ID needed to pull project-specific testing data. ### Retrieve Run Statuses Get a summary of recent test executions, including pass/fail counts and commit information for any given project run. ### Pinpoint Failure Causes Inspect specific failed spec instances to pull video URLs, screenshots, or detailed error messages. ### Audit Performance Degradation Generate reports that highlight the slowest tests and track their average duration metrics (p95/avg). ### Identify Intermittent Bugs Produce dedicated reports listing flaky tests, showing how often they pass or fail across your codebase. ## Use Cases ### Debugging a recent failure A QA Engineer sees a red status on the dashboard. Instead of clicking through, they ask the agent to find all failed specs in that run using `get_instances`. The agent responds with links and error messages for the top three failures. ### Auditing quarterly reliability An Engineering Manager needs a report showing process quality across Q2. They ask the agent to generate an enterprise run summary using `report_runs` for the last quarter, receiving data formatted for a board presentation. ### Tackling 'ghost' bugs A developer suspects a test is flaky but can't prove it. They ask the agent to run `report_flaky` and get confirmation that the 'User Profile Update' test has failed three times this month, narrowing down the root cause. ### Reviewing pipeline bottlenecks A DevOps team member notices build time creep. They ask the agent to run `report_slow` and get a list of tests that have exceeded an average duration threshold, allowing them to prioritize refactoring. ## Benefits - Stop manually checking run logs. You can use `get_runs` to list recent executions and immediately see the status, commit info, and total pass/fail counts for a project. - When something breaks, you don't waste time hunting through videos. Use `get_instance` to pull up detailed error messages and screenshots right from your agent chat. - Improve CI reliability by running `report_flaky`. This tool identifies intermittent bugs, tracking failure rates and last known dates for those hard-to-catch issues. - Track performance degradation using `report_slow`. This gives you concrete data on which tests are slowing down your build process based on p95 metrics. - Need historical context? The combination of `get_runs` and `report_tests` lets you gather massive amounts of run summary and granular test data for auditing or BI dashboards. ## How It Works The bottom line is you get instant answers about your E2E test quality, without opening the Cypress UI. 1. Subscribe to the MCP and supply your Cypress Cloud Enterprise API Key along with your Project ID. 2. Connect this MCP through any compatible client, like Cursor or Claude, giving your agent access to the test data endpoints. 3. Ask your agent a question—like 'What failed in the last run?'—and it uses the tools to retrieve and summarize the results. ## Frequently Asked Questions **How do I find my project ID using list_projects?** You call `list_projects`. This tool returns all your organizational projects, providing the exact 6-character IDs you need to reference in subsequent report calls. **What is the difference between get_runs and get_instances?** `get_runs` gives a high-level summary of an entire test job (pass/fail counts, total duration). `get_instances` drills down into that run to list every single spec file execution within it. **Can I get performance data on slow tests with report_slow?** Yes. `report_slow` generates a dedicated report showing the slowest tests, quantifying their issue using average (avg) and 95th percentile (p95) duration metrics. **Does get_tests show me individual failures?** Yes. `get_tests` lists every single test title within an instance, showing its specific state (passed/failed/skipped), along with error messages if it failed. **When I use get_instance, what detailed debugging artifacts can I retrieve for a failed test?** The tool gives you full debug context. You don't just get an error message; you also receive screenshots and video URLs specific to that failing spec instance. This lets you review exactly what the browser saw when the failure happened. **If I need a historical view of test results, how do I use report_runs?** You must provide a start date for this tool. It generates an enterprise run summary report, giving you aggregated data across multiple runs. This is ideal for feeding into BI dashboards or long-term auditing. **What metrics does report_flaky use to identify unreliable tests?** It identifies intermittent failures by analyzing historical pass/fail cycles. The output provides the test name, a calculated flake rate percentage, and crucially, lists the last dates that specific test failed. **Is report_tests better for overall reporting than just listing results with get_tests?** Yes, `report_tests` provides comprehensive, individual test-level data. While `get_tests` lists current state and errors, this report fetches the full historical status and error messages for a much broader dataset.