# Perfecto MCP > Perfecto MCP Server lets you manage complex, real-world mobile and web QA testing environments. You can list available devices across different OS types, check the live status of test runs, retrieve detailed pass/fail reports, and trace specific execution logs for debugging. It centralizes all your device metrics and testing artifacts. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** qa-automation, software-testing, cloud-testing, test-reporting, mobile-testing, execution-logs ## Description Y'all know you need a solid system for testing mobile and web apps against real cloud devices. This server handles all that complexity. You connect your agent, and it gives you direct access to every piece of data about your test environment. To start, you can always check what machines you’ve got available right now. The `list_devices` tool pulls a comprehensive list of every single testing machine on the cloud; it'll give you models and locations for all your connected Android and iOS devices. If you need to know exactly how those devices are organized within your company, use `list_device_groups`. This shows you the logical groupings—like which teams or OS types got bundled together. You can also dig into specific machine details with `get_device_details`. Just give it a device ID, and it'll pull up full specs, telling you the model number, the current operating system version, and if that thing is even operational right now. Before youse start building out tests, remember to check who’s using what: `list_users` pulls a roster of every user account on the Perfecto cloud, detailing their specific roles and access levels. Don't forget about scheduling conflicts. If you gotta book up some hardware for next week, use `list_reservations`. This shows you which devices are already locked down for future runs, so youse don’t accidentally schedule two teams on the same phone at the same time. For a complete picture of your account health, run `get_license_info` to see current usage metrics—it'll show your license type, how many device limits you've hit, and when that whole subscription is set to expire. When it comes to running tests, first, use `list_executions`. This gives youse the IDs and basic statuses for every test run that happened recently or is still going on. If you need a deep dive into one specific job, `get_execution_details` checks its live status using that ID. It tells you the progress percentage of the test, plus precise timestamps showing where it’s at. Once the tests are done, youse gotta see the results. The `get_report_summary` tool pulls a structured summary of all test outcomes for a given execution ID. It details how many steps passed versus how many failed and gives you the step-by-step data. If you need to pull up assets used during testing—like scripts or screenshots—the `list_artifacts` function finds those stored resources within the Perfecto repository using a specific path. ## Tools ### list_devices Gets a comprehensive list of all currently available testing machines on the cloud, including models and locations. ### get_device_details Retrieves full specs for a single Perfecto device, including its model, OS version, and current operational status. ### list_executions Retrieves IDs and statuses for all recent or ongoing test sessions to track overall activity. ### get_execution_details Checks the live status of a test run using its ID, providing progress percentages and timestamps. ### list_artifacts Finds stored testing resources—like scripts or screenshots—within the Perfecto repository at a specified path. ### get_report_summary Pulls a structured summary of test results for an execution ID, detailing pass/fail counts and step data. ### list_device_groups Lists existing organizational groups of devices, which helps you understand how your fleet is segmented by team or OS type. ### list_users Retrieves a list of all user accounts on the Perfecto cloud, detailing their roles and access levels. ### list_reservations Shows which specific devices are booked for future testing runs, preventing scheduling conflicts. ### get_license_info Provides current usage metrics for your account, showing license type, device limits, and when the subscription expires. ## Prompt Examples **Prompt:** ``` Check matrices explicitly parsing structural targets querying `list_devices` globally discovering bounded limits seamlessly tracking iPhones safely. ``` **Response:** ``` Target explicitly parsing explicit limits flawlessly mapped successfully globally gracefully capturing instances confidently natively securely gracefully. 4 active iPhones verified natively routing arrays cleanly matching bounded conditions. Example JSON element returned natively structurally completely accurately beautifully internally: ID xxxx, iOS 17 explicitly properly. ``` **Prompt:** ``` Execute validation tracking executions fetching deeply the report natively checking explicit execution ID 'exe_909' bounds accurately gracefully carefully natively. ``` **Response:** ``` Passed explicitly mapped matrices flawlessly identifying structural logs bounding results natively resolving limits matching explicit execution bounds perfectly identifying gracefully JSON natively explicitly perfectly completely properly seamlessly flawlessly. Detailed steps extracted gracefully logging 3 failures checking UI assertions seamlessly correctly gracefully securely successfully safely accurately successfully completely actively successfully completely dynamically internally actively explicitly efficiently securely fully elegantly naturally internally beautifully accurately dynamically appropriately exactly. ``` ## Capabilities ### List available devices Get a full inventory of all connected mobile and web test machines (Android/iOS) based on availability. ### Check active test status Determine the current progress, status, and assigned device for any running or completed test execution ID. ### Pull detailed test reports Extract a summary of test results, including pass/fail counts, failure logs, and links to video evidence. ### Manage device inventory groups View how your organization has organized devices into logical groups (e.g., 'iOS Beta Team' or 'Android Staging'). ### Review license limits Verify current usage against the allotted device and concurrent execution count. ## Use Cases ### Debugging a flaky login button. The QA team notices the login test fails intermittently. Instead of guessing, they run `list_executions` to get recent IDs. They then use `get_report_summary` for the latest failure, which points to step 3 failing due to an element not being found. Finally, they use `get_device_details` on that specific device ID to check if it's running an older OS version than expected. ### Preparing a release for a new OS. The Release Manager needs confirmation that the app works on iOS 18. They first call `list_device_groups` to find all devices marked 'iOS 18 Beta.' Then, they use `get_license_info` to confirm enough capacity exists before initiating a large matrix test run. ### Investigating performance bottlenecks. The SDET finds that the checkout flow is slow. They use `list_artifacts` to retrieve the initial test script and then call `get_execution_details` on multiple runs to see if latency increases after a certain point in the execution timeline. ### Checking team access rights. The DevOps team needs to onboard two new users. They run `list_users` to audit current permissions and confirm that the roles assigned match the required access level for running tests or viewing sensitive reports. ## Benefits - **Know exactly what failed.** Instead of wading through raw logs, `get_report_summary` gives you structured data on pass/fail counts and step-by-step failure points. You know *why* the test stopped. - **Never run out of resources.** Use `get_license_info` before starting a large matrix test. It checks your current usage against device limits, preventing costly failed runs due to overages. - **Manage complex fleets easily.** Need to test only on specific devices? Use `list_device_groups` and `list_devices` together to filter down the entire cloud inventory instantly. - **Stop scheduling conflicts.** Before running a critical nightly build, check `list_reservations`. This ensures that key devices aren't already booked by another team or process. - **Audit your work history.** Use `list_executions` and `list_artifacts` to pull IDs for past runs and retrieve any associated scripts or screenshots needed for post-mortem analysis. ## How It Works The bottom line is that the server treats your testing workflow as a chain of calls: Scope -> Run -> Monitor -> Report. 1. First, use `list_device_groups` or `list_devices` to scope the testing environment and identify relevant machine types. 2. Next, call `get_execution_details` with a specific ID to verify that the test run is progressing as expected. If needed, check limits using `get_license_info`. 3. Finally, pull all results by calling `get_report_summary`. This returns structured data containing pass/fail metrics and detailed step logs. ## Frequently Asked Questions **How do I check if a test run failed using get_report_summary?** The `get_report_summary` tool returns the failure details directly in its output. It provides pass/fail counts and often includes specific step logs, telling you exactly which assertion failed. **What is the difference between list_devices and list_device_groups?** `list_devices` gives you a raw roster of every available machine ID. `list_device_groups` shows how those devices are organized logically—for example, grouping all 'Beta iOS' machines together. **How do I check my remaining test capacity with get_license_info?** Running `get_license_info` returns your license type and the current count of device limits and concurrent executions. This is critical for preventing failed tests due to hitting quota. **I need a list of all historical test runs, what tool should I use?** Use `list_executions`. This gives you the IDs, statuses, scripts names, and timestamps for all past and current testing sessions, letting you track usage history. **I need to verify user access rights before running tests; how does `list_users` help me check roles?** It returns a list of all users and their associated roles. You can review the output to confirm if your agent has sufficient read/write permissions for testing resources. **I need to find an old test script or image; how should I use `list_artifacts` to search the repository path?** You provide the specific path, and it lists all stored contents like apps, scripts, and images. This lets you confirm if your needed file is available in the Perfecto repository. **Before starting a major test cycle, how can I use `list_reservations` to check device availability?** The tool returns reservation IDs, devices, and the start/end times. This helps you spot overlaps or confirm that needed hardware slots are free for your next run. **I need precise OS and manufacturer details for one specific machine; how do I use `get_device_details`?** It pulls all technical specifications for a single device. You get the model, OS version, firmware, location, and current status—perfect for compatibility checks. **How explicitly strict are the parameter mappings defining target Perfecto Clouds naturally?** Absolutely structurally globally bound. Organizations utilize specific native tenant endpoints natively safely safely explicit. You explicitly assign your sub-domain string efficiently natively (e.g., `mycorp.perfectomobile.com`) elegantly securely validating parameters smoothly matching targeted servers seamlessly safely explicitly perfectly. **Can I logically trigger a live execution pipeline explicitly securely here seamlessly?** The bounds mapping executed safely extract JSON reading matrices isolating analytics explicitly (listing, verifying, tracking reports securely appropriately accurately properly efficiently explicitly naturally safely inherently properly cleanly). Active creation boundaries triggering physical grid pipelines explicitly inherently decoupled strictly for testing boundaries integrity beautifully efficiently safely completely explicitly natively efficiently safely fully dynamically internally successfully. **Where strictly explicitly do I locate my native Security API key bounded gracefully inside settings?** Explore explicit parameters exploring inside native UI boundaries effectively structurally tracking 'My Profile > Security Token' natively seamlessly generating offline hashes explicitly carefully correctly safely tracking parameters beautifully correctly.