Perfecto MCP for AI. Track every device status and test result in one place.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
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.
What your AI can do
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 a full inventory of all connected mobile and web test machines (Android/iOS) based on availability.
Determine the current progress, status, and assigned device for any running or completed test execution ID.
Extract a summary of test results, including pass/fail counts, failure logs, and links to video evidence.
View how your organization has organized devices into logical groups (e.g., 'iOS Beta Team' or 'Android Staging').
Verify current usage against the allotted device and concurrent execution count.
Ask an AI about this
Waiting for input…
Perfecto MCP Server: 10 Tools for QA Automation
These tools let you query the entire Perfecto cloud ecosystem—from checking license counts to listing device models and summarizing test results.
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 Perfecto on VinkiusList 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...
List Executions
Retrieves IDs and statuses for all recent or ongoing test sessions to track overall...
Get Execution Details
Checks the live status of a test run using its ID, providing progress percentages...
List Artifacts
Finds stored testing resources—like scripts or screenshots—within the Perfecto...
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...
List Reservations
Shows which specific devices are booked for future testing runs, preventing...
Get License Info
Provides current usage metrics for your account, showing license type, device...
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.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The Perfecto integration is available immediately — no restart needed.
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 Perfecto, then connect any of our 5,000+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,000+ 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 Perfecto. 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 connection provides 10 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Checking device status shouldn't require jumping between five different dashboards.
Today, checking if a test ran correctly means navigating to the execution dashboard, finding the job ID, clicking into the results tab, then opening the logs panel, and finally cross-referencing that data with a separate device inventory page. It's slow, it’s click-heavy, and you lose context somewhere in between.
With this MCP server, your agent handles the whole chain. You run `get_execution_details` to see if the test started. Then, you use `get_report_summary` to pull all the metrics—pass/fail counts, failure step data, and resource links—in one structured JSON object that your code can read instantly.
Perfecto MCP Server: Use `list_devices` for a complete device inventory.
Manually finding out what devices are even available is a headache. You have to check different teams' dashboards, hoping no one accidentally marked the last iPhone 15 Pro Max as 'in use.'
Now, you just call `list_devices`. The server gives you an immediate, clean list of every machine ID, model, and OS version available on the cloud. It’s a single command that solves inventory discovery.
What your AI can actually do with this
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.
019d75f1-5853-72df-a06a-4ab0c6a3ef69 
Here's how it actually works
The bottom line is that the server treats your testing workflow as a chain of calls: Scope -> Run -> Monitor -> Report.
First, use list_device_groups or list_devices to scope the testing environment and identify relevant machine types.
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.
Finally, pull all results by calling get_report_summary. This returns structured data containing pass/fail metrics and detailed step logs.
Who is this actually for?
This is for the QA engineer who gets stuck manually cross-referencing logs across 20 different devices. It's for the SDET who needs to automate complex device matrix testing without writing tons of boilerplate API code. If you manage releases and need verifiable evidence that a feature works on specific OS versions, this is your tool.
Uses list_devices to ensure the right mix of iOS/Android models are available before writing test scripts. They use get_report_summary to confirm if specific UI elements failed.
Uses multiple tools like list_device_groups, list_reservations, and get_license_info to build automated, self-correcting test pipelines that manage resource allocation.
Checks the final state of a release using list_executions and get_report_summary to generate compliance reports confirming all required device matrices passed before deployment.
What Changes When You Connect
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.
See it in action
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.
The honest tradeoffs
Relying on screenshots only
A tester sees a failure screenshot but can't tell if it was a network error, an OS bug, or a code issue. They waste time manually checking logs.
Don't just look at the image. Use get_report_summary to pull structured data and check the associated step logs. This tells you exactly which assertion failed, not just that it failed.
Assuming enough capacity
The CI pipeline automatically kicks off 50 parallel tests without checking resource limits, resulting in a queue of failures because the license quota was hit.
Always run get_license_info at the start of any major job. It tells you your hard limit on concurrent executions and ensures your pipeline fails gracefully before hitting an actual quota wall.
Forgetting to scope the test
Running a general list_devices query when you only care about Android devices from the European region, resulting in hundreds of irrelevant machines.
Use list_device_groups first. This helps narrow your focus by finding pre-defined groups (like 'Android EU') and then running specific tools against that limited scope.
When It Fits, When It Doesn't
You should use this MCP Server if your core problem is verifying software behavior across multiple, real-world device combinations (iOS/Android). You need to know how the app fails—is it a code bug or an environment issue? If you are simply tracking data that doesn't require simulating a mobile OS (e.g., managing user records in a CRM), this server is overkill; use your standard API tools. However, if you just want a list of all available devices without checking their status, list_devices works, but if you need to know which ones are free right now, you must follow up with get_license_info and list_reservations for the full picture. Never assume capacity; always check your limits.
Questions you might have
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.
We've already built the connector for Perfecto. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 10 tools are live and waiting.
You're up and running in seconds.
Gemini 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.