Sauce Labs MCP Server
OfficialThis server lets you interact with Sauce Labs' testing platform via natural language, covering account management, devices, test jobs, builds, storage, tunnels, and real-device cloud operations.
Account & organization: view account info, list/search users, teams, service accounts, and active team
Device management: list device status, get device details, and view private devices
Test job analysis: retrieve recent jobs, get job details, download logs/videos/screenshots/assets for VDC and RDC jobs
Build monitoring: search builds, get build details, list jobs in a build, and associate jobs with builds
Storage management: list uploaded files/groups, upload apps, and update app group settings
Tunnel monitoring: list tunnels, get tunnel info, see current jobs per tunnel, and fetch Sauce Connect downloads
Network/HAR analysis: fetch and filter HAR network capture data efficiently with caching
Real Device Cloud (RDC) operations: create/list/delete sessions, discover devices, install/launch/uninstall apps, interact with devices (screenshots, shell commands, files), proxy network traffic, simulate network conditions, and manage Appium/WDA
Provides comprehensive integration with Sauce Labs testing platform, enabling management of device cloud resources, test job analysis, build monitoring, storage management, and tunnel monitoring across 300+ real devices and virtual machines
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Sauce Labs MCP Server show me the status of my recent test jobs"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Sauce Labs MCP Server
A Model Context Protocol (MCP) server that provides comprehensive integration with the Sauce Labs testing platform. This package includes two complementary MCP servers enabling AI assistants to interact with Sauce Labs' device cloud, manage test jobs, analyze builds, and monitor testing infrastructure through natural language conversations.
Prefer a hosted, more feature-rich option? Sauce MCP is the
official MCP server hosted by Sauce Labs at https://mcp.saucelabs.com. There is nothing to install or update, and it
offers a broader tool set than this package, including live real-device control (tap, type, screenshot, app
install/launch), network capture, and AI-powered test case authoring, execution, and scheduling. See
Connect your AI client for setup instructions.
Servers
This package provides two separate MCP servers optimized for different use cases:
sauce-api-mcp (Core Server) — Full Sauce Labs API integration for account management, device discovery, job analysis, builds, storage, and tunnels.
sauce-api-mcp-rdc (RDC Server) — Real Device Cloud (RDC) focused server. Dynamically generates MCP tools at startup
from the official Sauce Labs OpenAPI spec using FastMCP with an OpenAPIProvider,
so the tool set is always up-to-date without code changes. Includes a small set of handwritten tools for endpoints that
need special handling (binary payloads, session lifecycle, app installation polling).
Both servers can be configured simultaneously in your LLM client for full Sauce Labs coverage.
Related MCP server: MCP Appium
Features
🚀 Core Capabilities
Account Management: View account details, team information, and user permissions
Device Cloud Access: Browse 300+ real devices (iOS, Android) and virtual machines
Test Job Management: Retrieve recent jobs, analyze test results, and debug failures
Build Monitoring: Track build status, view job collections, and analyze test suites
Storage Management: Manage uploaded apps and test artifacts
Tunnel Monitoring: Check Sauce Connect tunnel status and configuration
🔧 Advanced Features
Real-time Device Status: Monitor device availability and usage across data centres
Cross-platform Testing: Support for both Virtual Device Cloud (VDC) and Real Device Cloud (RDC)
Test Analytics: Detailed job information including logs, videos, and performance metrics
Team Collaboration: Multi-team support with proper access controls
Dynamic RDC API:
sauce-api-mcp-rdcauto-discovers the latest RDC v2 endpoints from the OpenAPI spec at startup; the cached spec is used as a fallback when the network is unavailableResponse shaping: Large API list responses are automatically truncated to keep LLM context budget under control ( configurable via
SAUCE_MCP_MAX_RESPONSE_ITEMS)File safety: File push/pull operations on devices are restricted to
~/.sauce-mcp/files/to prevent path traversal
Prerequisites
Python 3.10+
pipSauce Labs account with API access
Claude Desktop, Gemini CLI, Goose, or another MCP-compatible LLM client
Installation
Install the package from PyPI:
pip install sauce-api-mcpThis installs both servers and registers their command-line entry points:
sauce-api-mcp— core serversauce-api-mcp-rdc— RDC OpenAPI server
Verify installation:
which sauce-api-mcp
which sauce-api-mcp-rdcConfiguration for LLM Clients
Claude Desktop (Mac / Linux / Windows)
Locate your Claude Desktop config file:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.jsonLinux:
~/.config/Claude/claude_desktop_config.json
Find your Python installation's
bindirectory:python3 -c "import sys; print(sys.prefix + '/bin')"Add both servers to your config:
{ "mcpServers": { "sauce-api-mcp-core": { "command": "/path/to/bin/sauce-api-mcp", "env": { "SAUCE_USERNAME": "your-sauce-username", "SAUCE_ACCESS_KEY": "your-sauce-access-key" } }, "sauce-api-mcp-rdc": { "command": "/path/to/bin/sauce-api-mcp-rdc", "env": { "SAUCE_USERNAME": "your-sauce-username", "SAUCE_ACCESS_KEY": "your-sauce-access-key" } } } }Restart Claude Desktop to load the servers.
Gemini CLI
Add to ~/.gemini/settings.json:
{
"mcpServers": {
"sauce-api-mcp-core": {
"command": "/path/to/bin/sauce-api-mcp",
"env": {
"SAUCE_USERNAME": "your-sauce-username",
"SAUCE_ACCESS_KEY": "your-sauce-access-key"
}
},
"sauce-api-mcp-rdc": {
"command": "/path/to/bin/sauce-api-mcp-rdc",
"env": {
"SAUCE_USERNAME": "your-sauce-username",
"SAUCE_ACCESS_KEY": "your-sauce-access-key"
}
}
}
}Goose
Add to ~/.config/goose/config.yaml:
sauce-api-mcp-core:
cmd: /path/to/bin/sauce-api-mcp
description: Sauce Labs MCP (Core)
enabled: true
envs:
SAUCE_USERNAME: your-sauce-username
SAUCE_ACCESS_KEY: your-sauce-access-key
type: stdio
sauce-api-mcp-rdc:
cmd: /path/to/bin/sauce-api-mcp-rdc
description: Sauce Labs MCP (RDC)
enabled: true
envs:
SAUCE_USERNAME: your-sauce-username
SAUCE_ACCESS_KEY: your-sauce-access-key
type: stdioEnvironment Variables (Alternative)
Instead of adding credentials to config files, you can export them as environment variables:
export SAUCE_USERNAME="your-sauce-username"
export SAUCE_ACCESS_KEY="your-sauce-access-key"Then omit the env block from your config. Both servers will automatically pick them up.
Configuration
Required Environment Variables
Variable | Description |
| Your Sauce Labs username |
| Your Sauce Labs access key (found in Account Settings) |
Optional Environment Variables
Variable | Default | Description |
|
| Data centre region: |
|
| Maximum list items returned before truncation (RDC server) |
Getting Your Sauce Labs Credentials
Log into your Sauce Labs account
Navigate to Account → User Settings
Copy your Username and Access Key
Troubleshooting Installation
"Command not found: sauce-api-mcp"
The entry point script isn't in your PATH. Use the full path approach:
python3 -m pip list | grep sauce-api-mcp
python3 -c "import sys; print(sys.prefix + '/bin/sauce-api-mcp')""ENOENT: no such file or directory" in MCP client
The MCP client is using a different Python environment. Solutions:
Use the full absolute path (recommended) — update your config with the path printed by
python3 -c "import sys; print(sys.prefix + '/bin/sauce-api-mcp')", not justwhich sauce-api-mcpModule invocation (fallback):
"command": "python3", "args": ["-m", "sauce_api_mcp.main"]
Example Prompts
"Show me my recent test failures"
"Find available iPhone 16 devices"
"Analyse the performance of my latest build"
"Open a session on a Samsung device and install my app"
"What tunnels do I have running right now?"
Available Tools
Core Server (sauce-api-mcp)
Account & Organisation
Tool | Description |
| Retrieve current user account information |
| Find users in your organisation |
| Get detailed user information |
| Find teams in your organisation |
| Get team details |
| List all members of a specific team |
| List service accounts |
| Get service account details |
| Get the active team for the authenticated user |
Device Management
Tool | Description |
| List all devices and their current status |
| Get detailed information about a specific device |
| List private devices available to your account |
Test Jobs
Tool | Description |
| Retrieve your most recent test jobs |
| Get comprehensive details about a specific job |
| List active jobs on real devices |
| Get details about a specific real device job |
| Download job assets (logs, videos, screenshots) |
Builds
Tool | Description |
| Search for builds with filters |
| Get detailed information about a specific build |
| Get the build associated with a job |
| List all jobs within a build |
Storage
Tool | Description |
| List uploaded application files |
| List app storage groups |
| Get settings for a storage group |
| Upload an app file to Sauce Storage |
| Update app group settings (resigning, instrumentation, etc.) |
Tunnels
Tool | Description |
| List active Sauce Connect tunnels |
| Get details about a specific tunnel |
| See how many jobs are using a tunnel |
| Get download URLs for Sauce Connect versions |
Test Assets & Logs
Tool | Description |
| Retrieve test artifacts for a VDC job |
| Get structured test execution logs for a VDC job |
| Get HAR network capture data with filtering |
| Filter cached HAR data efficiently (avoids re-downloading) |
RDC Server (sauce-api-mcp-rdc)
The RDC server auto-generates tools from the Sauce Labs RDC v2 OpenAPI spec. The full tool list varies as the spec evolves, but the categories below are always present.
Session Management
Tool | Description |
| Allocate a real device and return an ACTIVE session. Polls until ACTIVE or times out (~55 s) |
| List current device sessions with optional filtering |
| Close a session and release the device back to the pool |
| Get full details of a specific session |
Device Discovery
Tool | Description |
| Browse the full device catalogue with OS/model filters |
| Get live availability status of devices |
App Management
Tool | Description |
| Start an app installation on a device (returns an installation ID) |
| Poll installation status — call repeatedly until FINISHED |
| Launch an already-installed app |
| Remove an app from a device |
| List ongoing or recent app installations |
| Install an app from Sauce Storage |
Device Interaction
Tool | Description |
| Capture the current device screen |
| Open a URL or deep link on the device |
| Run an adb shell command (Android) |
| Change device settings (orientation, locale, etc.) |
File Operations
Tool | Description |
| Upload a local file to the device (restricted to |
| Download a file from the device |
| List files in a device directory |
| Delete a file from the device |
| Get metadata about a file or directory on the device |
Network & Proxy
Tool | Description |
| Forward HTTP requests through the device proxy |
| Capture network traffic |
| Simulate network conditions |
| List available network profiles |
| Restore normal connectivity |
Appium
Tool | Description |
| Start a hosted Appium server co-located with the device |
| Check if Appium is running and get its endpoint URL |
| List available Appium versions |
| Launch WDA on an iOS device |
| Check WDA status |
Development Setup
Prerequisites
Python 3.10+
uvpackage managerGit
Clone and Setup
git clone https://github.com/saucelabs/sauce-api-mcp.git
cd sauce-api-mcp
uv syncThis creates a virtual environment and installs all dependencies (including test extras) in editable mode.
Project Structure
sauce-api-mcp/
├── src/sauce_api_mcp/
│ ├── main.py # Core server — hand-written MCP tools
│ ├── rdc_dynamic.py # RDC server — OpenAPIProvider + hand-written tools
│ ├── models.py # Pydantic response models
│ └── shared/ # Shared utilities
├── tests/ # Test suite
├── server.json # MCP Registry manifest
├── pyproject.toml # Package config, entry points, PSR release config
└── uv.lock # Locked dependenciesRunning the Servers Locally
uv run sauce-api-mcp
uv run sauce-api-mcp-rdcBoth will print Error: This server is not meant to be run interactively — this is expected (they communicate over
stdio with MCP clients, not the terminal).
To point your MCP client at a local development checkout:
{
"command": "/path/to/sauce-api-mcp/.venv/bin/sauce-api-mcp"
}Running Tests
Tests are split into three groups:
# Integration tests (no live credentials required)
uv run pytest -m "not live and not slow"
# Live tests (require SAUCE_USERNAME + SAUCE_ACCESS_KEY)
uv run pytest -m "live and not slow"
# Slow tests (allocate real devices — takes minutes)
uv run pytest -m "slow"
# Full suite
uv run pytestAdding Dependencies
uv add httpx
uv add --dev pytest-asyncioCI / Release Workflow
Continuous Integration
Every pull request targeting main runs three sequential jobs via build.yml:
test — integration tests across Python 3.10, 3.11, 3.12 (in parallel)
test-live — live tests on Python 3.12 (after
test)test-slow — slow tests on Python 3.12 (after
test-live)
Releases
Releases are triggered manually via the Release workflow (publish.yml) in GitHub Actions:
Go to Actions → Release → Run workflow
Choose the release type:
patch,minor,major, orprereleaseFor pre-releases, optionally set the token (
alpha,beta,rc)
The workflow then:
Bumps the version in
pyproject.tomlandserver.jsonusingpython-semantic-releaseCreates a
v*git tag and a GitHub Release with auto-generated changelogPublishes stable releases to PyPI and the MCP Registry
Publishes pre-releases (alpha/beta/rc) to TestPyPI only
Contributing
We welcome contributions! See CONTRIBUTING.md for guidelines.
Getting Help
Sauce Labs Documentation: docs.saucelabs.com
API Reference: docs.saucelabs.com/dev/api
Support: Contact Sauce Labs support through your account dashboard
GitHub Issues: Report bugs or request features
Changelog
For a full history of releases and changes, see the GitHub Releases page.
v1.1.0
Merged
sauce-api-mcpandsauce-labs-mcp(RDC OpenAPI) into single monorepo packageAdded
sauce-api-mcp-rdcentry point for the RDC-focused serverMigrated RDC server from deprecated
FastMCPOpenAPItoOpenAPIProvider + FastMCP(fastmcp 3.x)Automated release workflow via
workflow_dispatchwithpython-semantic-release; release type chosen by the author ( patch/minor/major/prerelease)CI split into three sequential stages: integration tests (matrix 3.10–3.12) → live tests → slow tests
Locked dependencies with
uv.lockfor reproducible installs
v1.0.3
Updated to Apache License 2.0 (previously MIT)
v1.0.2
Submitted to official MCP Registry
Added Python 3.9 support
v1.0.1
Overhauled README with improved install instructions
v1.0.0
Initial release with full Sauce Labs API integration
Made with ❤️ for the testing community
License
Apache 2.0 (versions 1.1.0+)
Versions prior to 1.0.3 were released under the MIT License.
Disclaimer of Warranties
THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Limitation of Liability
IN NO EVENT SHALL SAUCE LABS, INC. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ( INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
General Use
The MCP Server is provided as a free and open-source tool to facilitate interaction with publicly available APIs. Users are free to modify and distribute the software under the terms of the Apache License 2.0.
By using this software, you acknowledge that you are doing so at your own risk and that you are responsible for your own compliance with all applicable laws and regulations.
Indemnification
You agree to indemnify and hold harmless Sauce Labs, Inc. ("Sauce Labs"), its officers, directors, employees, and agents from and against any and all claims, liabilities, damages, losses, or expenses, including reasonable attorneys' fees and costs, arising out of or in any way connected with your access to or use of this software.
This includes, but is not limited to:
Your Interaction with Third-Party LLM Providers: You acknowledge that this software utilises publicly available APIs for interaction with a Large Language Model (LLM). You are solely responsible for your use of any third-party LLM services, including your adherence to the terms and conditions of the LLM provider and any costs associated with your use, such as token fees. Sauce Labs has no control over, and assumes no responsibility for, the content, privacy policies, or practices of any third-party LLM providers.
Content Generated by the LLM: You are solely responsible for the content generated, received, or transmitted through your use of the MCP Server and the underlying LLM. Sauce Labs does not endorse and has no control over the content of communications made by you or any third party through the server.
Your Code and Modifications: Any modifications, enhancements, or derivative works you create based on the MCP Server are your own, and you are solely responsible for their performance and any liabilities that may arise from their use.
Available Tools
34 toolsfilter_har_dataA
Filters HAR data with in-memory caching for efficient multiple queries.
**Key difference from get_network_har_file**: This method caches the full HAR
data in memory after the first call, making subsequent filtering operations
instant without re-downloading from Sauce Labs.
First call for a job_id downloads and caches the full HAR data.
Subsequent calls filter the cached data instantly.
:param job_id: The Sauce Labs Job ID
:param filter_category: Predefined categories ("analytics", "social", "api", etc.)
:param custom_domains: Domain patterns to include
:param resource_types: Resource types to include (Script, XHR, Image, etc.)
:param status_codes: HTTP status codes to include
:return: Filtered HAR data with cache metadata
Examples:
- filter_har_data(job_id, filter_category="analytics") # First call: downloads + caches
- filter_har_data(job_id, filter_category="social") # Subsequent: instant filtering
- filter_har_data(job_id, custom_domains=["facebook"]) # Also instant
Inputs: job_id (required), status_codes, custom_domains, resource_types, +1 more.
get_account_infoA
Provides the current user's Sauce Labs account information, including username, jobs run, minutes used, and overall account status. Useful for a quick overview of account activity.
Inputs: no named parameters. Returns: result
get_buildA
Retrieve the details related to a specific build by passing its unique ID in the request.
:param build_source: Required. The type of device for which you are getting builds. Valid values are: 'rdc' -
Real Device Builds, 'vdc' - Emulator or Simulator Builds
:param build_id: Required. The unique identifier of the build to retrieve. You can look up build IDs in your
organization using the Lookup Builds endpoint.
Inputs: build_id (required), build_source (required). Returns: result
get_build_for_jobB
Retrieve the details related to a specific build by passing its unique ID in the request.
:param build_source: Required. The type of device for which you are getting builds. Valid values are: 'rdc'
(Real Device Builds), 'vdc' (Emulator or Simulator Builds)
:param job_id: Required. The unique identifier of the job whose build you are looking up. You can look up job
IDs in your organization using the Get Jobs endpoint.
Inputs: job_id (required), build_source (required). Returns: result
get_current_jobs_for_tunnelC
Returns the number of currently running jobs for the specified tunnel. The word "tunnel" in this context refers
to usage of the Sauce Connect tool.
:param username: Required. The authentication username of the owner of the requested tunnel.
:param tunnel_id: Required. The unique identifier of the requested tunnel.
Inputs: username (required), tunnel_id (required). Returns: result
get_devices_statusA
Returns a list of devices in the data center along with their current states. Each device is represented by a
descriptor, indicating its model, and includes information on availability, usage status, and whether it is
designated as a private device. Note that the inUseBy field is exposed only for private devices
isPrivateDevice: true. Users can view information about who is currently using the device only if they have
the required permissions. Lack of permissions will result in the inUseBy field being omitted from the response
for private devices.
This tool provides a lightweight overview of all devices. For detailed device specifications, use the
get_specific_device tool with the descriptor value as the device_id parameter.
Available States:
AVAILABLE Device is available and ready to be allocated
IN_USE Device is currently in use
CLEANING Device is being cleaned (only available for private devices)
MAINTENANCE Device is in maintenance (only available for private devices)
REBOOTING Device is rebooting (only available for private devices)
OFFLINE Device is offline (only available for private devices)
Note: The 'descriptor' field in each device object is the device identifier that should be used as the
'device_id' parameter in get_specific_device calls.
Inputs: no named parameters. Returns: result
get_job_detailsA
Retrieves the execution details of a particular job, by ID.
This method works for both Virtual Device Cloud (VDC) and Real Device Cloud (RDC) though
the returned data structure may vary between platforms.
Use this method first to understand what type of job you're working with:
- If 'device_name' contains mobile devices → RDC job → use get_specific_real_device_job_asset for assets
- If 'browser' field shows web browsers → VDC job → use get_test_assets for assets
:param job_id: The Sauce Labs Job ID (works for both VDC and RDC jobs).
:return: Detailed job information including status, timing, configuration, and platform-specific data.
Inputs: job_id (required). Returns: result
get_log_json_fileA
Shows the complete log of a Sauce Labs test, in structured json format.
IMPORTANT: This method only works with Virtual Device Cloud (VDC) jobs. For Real Device
Cloud (RDC) jobs, use get_specific_real_device_job_asset with asset_type='appiumLogs'
or 'deviceLogs' instead.
If this method fails with "asset not found", the job is likely an RDC job - try
get_specific_real_device_job_asset instead.
:param job_id: The Sauce Labs Job ID (VDC jobs only).
:return: Structured JSON log data with test commands, timing, and screenshots.
Inputs: job_id (required). Returns: result
get_my_active_teamA
Retrieves the Sauce Labs active team for the currently authenticated user.
Inputs: no named parameters. Returns: result
get_network_har_fileA
Retrieves and filters HAR file data from a Sauce Labs test job.
The tool can intelligently filter requests to reduce data size and focus analysis.
Use filter categories for common patterns, or specify custom filters for detailed control.
:param job_id: The Sauce Labs Job ID (works for VDC jobs with network capture enabled)
:param filter_category: Predefined filter categories:
- "analytics" - Google Analytics, Facebook Pixel, Adobe Analytics, Comscore, etc.
- "api" - Internal API calls (same domain as main site, JSON responses)
- "fonts" - Font loading requests (woff, woff2, ttf, etc.)
- "images" - Image resources (jpg, png, webp, svg, etc.)
- "scripts" - JavaScript files and external scripts
- "errors" - Failed requests (4xx, 5xx status codes)
- "slow" - Requests taking longer than 1 second
- "third-party" - All external domain requests
:param custom_domains: List of domain patterns to include (e.g., ["google", "facebook", "api.company.com"])
:param resource_types: List of resource types to include (e.g., ["Script", "XHR", "Image"])
:param status_codes: List of HTTP status codes to include (e.g., [200, 404, 500])
:return: Filtered HAR data structure with only matching requests
Examples:
- get_network_har_file(job_id, filter_category="analytics")
- get_network_har_file(job_id, filter_category="api")
- get_network_har_file(job_id, custom_domains=["retailmenot.com"], resource_types=["XHR"])
Inputs: job_id (required), status_codes, custom_domains, resource_types, +1 more.
get_private_devicesC
Get a list of private devices with their device information and settings.
Inputs: no named parameters. Returns: result
get_real_device_jobsB
Get a list of jobs that are actively running on real devices in the data center.
:param limit: The maximum number of jobs to return.
:param offset: Limit results to those following this index number. Defaults to 1.
:param type: Filter results to show manual tests only with LIVE.
Inputs: type, limit, offset. Returns: result
get_recent_jobsA
Retrieves a list of the most recent jobs run on Sauce Labs for the current user.
Allows specifying the number of jobs to retrieve, up to a maximum.
Useful for quickly checking the status of recent test runs.
:param limit: The upper limit (integer) of jobs to retrieve. Max is 100
Inputs: limit. Returns: result
get_service_accountC
Retrieves details of the specified service account.
:param id: Required. The unique identifier of the service account. You can find the uuid in the URL of the
service account details view in the Sauce Labs UI. You can also look up the uuid using the Lookup
Service Accounts endpoint.
Inputs: id (required). Returns: result
get_specific_deviceA
Get information about the device specified in the request.
:param device_id: Required. The unique identifier of a device in the Sauce Labs
data center. Use the 'descriptor' value from get_devices_status results.
Inputs: device_id (required). Returns: result
get_specific_real_device_jobB
Get information about a specific job running on a real device at the data center.
:param job_id: Required. The unique identifier of a job running on a real device in the data center. You can
look up job IDs using the Get Real Device Jobs endpoint.
Inputs: job_id (required). Returns: result
get_specific_real_device_job_assetA
Download a specific asset for a Real Device Cloud (RDC) job.
USE THIS METHOD WHEN:
- The job ran on a physical mobile device (iPhone, Android, etc.)
- get_test_assets returns an error about "Real Device job"
- get_log_json_file fails with asset not found errors
- You need logs/videos from mobile app testing
For web browser testing on virtual machines, use get_test_assets instead.
:param job_id: Required. The unique identifier of a job running on a real device in the data center. You can look up job
IDs using the Get Real Device Jobs endpoint.
:param asset_type: Required. The unique identifier of a job running on a real device in the data center. You can look up job
IDs using the Get Real Device Jobs endpoint. Possible values are:
'deviceLogs' - Device Logs | Appium, Espresso, XCUITest
'appiumLogs' - Appium Logs | Appium
'appiumRequests' - Appium Requests | Appium
'junit.xml' - JUnit XML | Espresso, XCUITest
'xcuitestLogs' - XCUITest Logs | XCUITest
'video.mp4' - Video | Appium, Espresso, XCUITest
'screenshots.zip' - Screenshots | Appium, Espresso
'network.har' - Network Logs | Appium, Espresso, XCUITest
'insights.json' - Device Vitals | Appium, Espresso, XCUITest
'crash.json' - Crash Logs | Appium
Inputs: job_id (required), asset_type (required). Returns: result
get_storage_filesB
Returns the set of files that have been uploaded to Sauce Storage by the requestor.
Inputs: no named parameters. Returns: result
get_storage_groupsA
Returns an array of groups (apps containing multiple files) currently in storage for the authenticated requestor.
Inputs: no named parameters. Returns: result
get_storage_groups_settingsA
Returns the settings of an app group with the given ID.
:param group_id: The unique identifier of the app group. You can look up group IDs using the Get App Storage Groups endpoint.
Inputs: group_id (required). Returns: result
get_teamA
Returns the full profile of the specified team. The ID of the team is the only valid unique identifier.
:param id: Required. The unique identifier of the team. You can look up the IDs of teams in your organization
using the Lookup Teams endpoint.
Inputs: id (required). Returns: result
get_test_assetsA
Returns the list of all assets for a test, based on the job ID.
IMPORTANT: Only use this method with Virtual Device Cloud (VDC) jobs. This will fail
with a 404 error for Real Device Cloud (RDC) jobs. If you get an error about
"Real Device job", use get_specific_real_device_job_asset instead.
To determine job type: RDC jobs typically have device names like "Samsung Galaxy" or "iPhone 14".
VDC jobs typically have browser names like "chrome", "firefox", or platform names like "Windows 11".
:param job_id: The Sauce Labs Job ID (VDC jobs only).
:return: JSON containing a list of assets, from which the URL can be derived.
Inputs: job_id (required). Returns: result
get_tunnel_informationB
Returns information about the specified tunnel. The word "tunnel" in this context refers to usage of
the Sauce Connect tool.
:param username: Required. The authentication username of the owner of the requested tunnel.
:param tunnel_id: Required. The unique identifier of the requested tunnel.
Inputs: username (required), tunnel_id (required). Returns: result
get_tunnels_for_userC
Returns Tunnel IDs or Tunnels Info for any currently running tunnels launched by or shared with the specified
user. The word "tunnel" in this context refers to usage of the Sauce Connect tool.
It also allows to filter tunnels using an optional "filter" parameter that may take the following values:
:param username: Required. The authentication username of the user whose tunnels you are requesting.
Inputs: username (required). Returns: result
get_tunnel_version_downloadsA
Returns the specific paths (URLs) to download specific versions of the SauceConnect tunnel software.
The word "tunnel" in this context refers to usage of the Sauce Connect tool.
:param client_version: Optional. Returns download information for the specified Sauce Connect client
version (For example, '5.2.3').
Inputs: client_version (required). Returns: result
get_userA
Returns the full profile of the specified user. The ID of the user is the only valid unique identifier.
:param id: Required. The user's unique identifier. Specific user IDs can be obtained through the lookup_users Tool
Inputs: id (required). Returns: result
list_team_membersB
Returns the number of members in the specified team and lists each member.
:param id: Required. Identifies the team for which you are requesting the list of members.
Inputs: id (required). Returns: result
lookup_buildsA
Queries the requesting account and returns a summary of each build matching the query, including the ID value,
which may be a required parameter of other API calls related to a specific build. You can narrow the results of
your query using any of the optional filtering parameters.
:param build_source: The type of device for which you are getting builds. Valid values are: 'rdc' - Real Device
Builds, 'vdc' - Emulator or Simulator Builds
:param user_id: Optional. Returns any builds owned by the specified user that the authenticated user is authorized to view. You can look up the IDs of users in your organization using the Lookup Users endpoint.
:param org_id: Optional. Returns all builds in the specified organization that the authenticated user is authorized to view.
:param group_id: Optional. Returns all builds associated with the specified group that the authenticated user is authorized to view.
:param team_id: Optional. Returns all builds for the specified team that the authenticated user is authorized to view.
:param status: Optional. Returns only builds where the status matches the list of values specified. Valid values are: running - Any job in the build has a state of running, new, or queued. error - The build is not running and at least one job in the build has a state of errored. failed - The build is not running or error and at least one job in the build has a state of failed. complete - The build is not running, error, or failed, but the number of jobs with a state of finished does not equal the number of jobs marked passed, so at least one job has a state other than passed. success -- All jobs in the build have a state of passed.
:param start: Optional. Returns only builds where the earliest job ran on or after this Unix timestamp. Note: If experiencing errors, try providing both start and end parameters together.
:param end: Optional. Returns only builds where the latest job ran on or before this Unix timestamp. Note: If experiencing errors, try providing both start and end parameters together.
:param limit: Optional. The maximum number of builds to return in the response.
:param name: Optional. Returns builds with a matching build name.
:param offset: Optional. Begins the set of results at this index number.
:param sort: Optional. Sorts the results in alphabetically ascending or descending order. Valid values are: asc - Ascending desc - Descending
Inputs: build_source (required), end, name, sort, +8 more. Returns: result
lookup_jobs_in_buildB
Returns information about all jobs associated with the specified build. You can limit which jobs are
returned using any of the optional filtering parameters.
:param build_source: Required. The type of test device associated with the build and its jobs. Valid values are:
rdc - Real Device Builds, vdc - Emulator or Simulator Builds
:param build_id: Required. The unique identifier of the build whose jobs you are looking up. You can look up
build IDs in your organization using the Lookup Builds endpoint.
:param modified_since: Optional. Returns only jobs that have been modified after this unicode timestamp.
:param completed: Optional. Returns jobs based on whether they completed, meaning the tests ran uninterrupted to
completion: true - Return jobs that have a completed state of true, false - Return jobs that have a
completed state of false.
:param errored: Optional. Returns jobs based on their errored state: true - Return jobs that have an errored
state of true, false - Return jobs that have an errored state of false.
:param failed: Optional. Returns jobs based on their failed state: true - Return jobs that have a failed state
of true, false - Return jobs that have a failed state of false.
:param finished: Optional. Returns jobs based on whether they have finished, meaning they are no longer
running, but may not have run to completion: true - Return jobs that have a finished state of true, false -
Return jobs that have a finished state of false.
:param new: Optional. Returns jobs based on their new state: true - Return jobs that have a new state of true,
false - Return jobs that have a new state of false.
:param passed: Optional. Returns jobs based on their passed state: true - Return jobs that have a passed state
of true, false - Return jobs that have a passed state of false.
:param public: Optional. Returns jobs based on whether they were run on public devices: true - Return jobs that
have a public state of true, false - Return jobs that have a public state of false.
:param queued: Optional. Returns jobs based on whether their current state is queued: true - Return jobs that
have a queued state of true, false - Return jobs that have a queued state of false.
:param running: Optional. Returns jobs based on whether they are currently in a running state: true - Return
jobs that are currently running, false - Return jobs that are not currently running.
:param faulty: Optional. Returns jobs based on whether they are identified as faulty, meaning either errored or
failed state is true. true - Return jobs that have a faulty state of true, false - Return jobs that have a
faulty state of false.
Inputs: build_id (required), build_source (required), new, failed, +9 more. Returns: result
lookup_service_accountsA
Lists existing service accounts in your organization. You can filter the results using the query parameters below.
:param id: Optional. Comma-separated service account IDs.
included in the provided list.
:param username: Optional. Limits the results to usernames that begin with the specified value. For example,
username=an would return all service accounts in the organization with usernames beginning with "an".
:param teams: Optional. Limit results to service account who belong to the specified team_ids. Specify multiple
teams as comma-separated values.
:param limit: Optional. Limit results to a maximum number per page. Default value is 20.
:param offset: Optional. The starting record number from which to return results.
Inputs: id, limit, teams, offset, +1 more. Returns: result
lookup_teamsA
Queries the organization of the requesting account and returns the number of teams matching the query and a
summary of each team, including the ID value, which may be a required parameter of other API calls related
to a specific team.You can filter the results of your query using the name parameter below.
:param id: Optional. Comma-separated team IDs. Allows to receive details of multiple teams at once. For example,
id=3d60780314724ab8ac688b50aadd9ff9,f9acc7c5b1da4fd0902b184c4f0b6324 would return details of teams with IDs
included in the provided list.
:param name: Optional. Returns the set of teams that begin with the specified name value. For example, name=sauce would
return all teams in the organization with names beginning with "sauce".
Inputs: id, name. Returns: result
lookup_usersA
Queries the organization of the requesting account and returns the number of users matching the query and a basic
profile of each user, including the ID value, which may be a required parameter of other API calls related to a
specific user. You can narrow the results of your query using any of the following filtering parameters.
:param id: Optional. Comma-separated user IDs. Allows to receive details of multiple user at once. For example,
id=3d60780314724ab8ac688b50aadd9ff9,f9acc7c5b1da4fd0902b184c4f0b6324 would return details of users with IDs
included in the provided list.
:param username: Optional. Limits the results to usernames that begin with the specified value. For example,
username=an would return all users in the organization with usernames beginning with "an".
:param teams: Optional. Limit results to users who belong to the specified team_ids. Specify multiple teams as
comma-separated values.
:param roles: Optional. Limit results to users who are assigned certain roles. Valid values are: 1 - Organization Admin,
4 - Team Admin, 3 - Member. Specify multiple roles as comma-separated values.
:param phrase: Optional. Limit results to users whose first name, last name, or email address begins with the specified value.
:param status: Optional. Limit results to users of the specifid status. Valid values are: 'active', 'pending', 'inactive'
:param limit: Optional. Limit results to a maximum number per page. Default value is 20.
:param offset: Optional. The starting record number from which to return results.
Inputs: id, limit, roles, teams, +4 more. Returns: result
update_storage_group_settingsB
Update app storage group settings for the specified group.
:param group_id: Required. The unique identifier of the app group.
:param proxy: Optional. Proxy configuration with 'host' and 'port' keys.
:param audio_capture: Optional. Enable/disable audio capture during testing.
:param proxy_enabled: Optional. Enable/disable proxy usage.
:param lang: Optional. Language setting (e.g., 'en_GB', 'en_US').
:param orientation: Optional. Device orientation preference.
:param resigning_enabled: Optional. Enable/disable app resigning (iOS only).
:param resigning: Optional. iOS-specific resigning settings dict with keys:
- image_injection: bool
- group_directory: bool
- biometrics: bool
- sys_alerts_delay: bool
- network_capture: bool
- vitals: bool (seen in other examples)
- backtrace: bool (seen in other examples)
:param instrumentation: Optional. Android-specific instrumentation settings.
:return: Updated settings response from API.
Inputs: group_id (required), lang, proxy, resigning, +5 more. Returns: result
upload_file_to_storageA
Uploads an app file to Sauce Storage for the purpose of mobile app testing or generic files to be used as Pre-Run
Executables and returns a unique file ID assigned to the uploaded file.Sauce Storage supports mobile app packages
in *.apk, *.aab, *.ipa, or *.zip format as well as any other file format.The maximum size of a single file is limited to 4GB.
:param payload: The path to the file you want to upload.
:param name: The portion of the payload value that is the actual file name (including the type extension).
:param description: A description to distinguish your app.
:param tags: An optional list of comma-separated tag names assigned to the uploaded file. Each tag name length
must be between 1 and 16 characters. Tag names must only consist of uppercase (A-Z), lowercase (a-z),
digits (0-9), underscore ("_"), hyphen ("-"), and dot (".") characters. Tag names are case-sensitive. It is
allowed to assign up to 10 tags to a single file.
:param project_name: An optional name for the project you want the file (group) to be assigned to. If the
project doesn't exist, it will be created. Project names can only consist of alphanumeric (uppercase and
lowercase) characters, along with underscores ("_"), hyphens ("-"), periods ("."), and spaces (" "). Project
names are case-sensitive and can be max 64 characters long.
:return: 201 Created.
400 Bad Request.
404 Not found.
Inputs: name (required), tags (required), file_path (required), description (required), +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 34 tools
Many tools are distinct, but several retrieval surfaces overlap: get_network_har_file and filter_har_data both filter HAR data with nearly identical parameters, job retrieval is split across get_recent_jobs, get_job_details, get_real_device_jobs, get_specific_real_device_job, and lookup_jobs_in_build, and device listing is split across get_devices_status and get_private_devices. Detailed descriptions mitigate much of the confusion, especially the VDC-vs-RDC guidance, but an agent can still misselect among similar tools.
Tool names consistently use snake_case with a verb-like prefix such as get_, lookup_, list_, upload_, update_, or filter_. There are minor deviations between get_/lookup_/list_ for read operations, but the pattern is predictable and no camelCase or chaotic naming is present.
With 34 tools, the surface is heavy for an MCP server and includes many narrowly scoped retrieval endpoints. While Sauce Labs is a broad platform, several tools are close variants and the count exceeds the comfortable 3-15 range, making navigation and selection harder.
The tool set covers many important Sauce Labs domains: jobs, builds, assets, logs, HAR data, tunnels, storage, users, teams, service accounts, and devices. However, it is mostly read-oriented and lacks obvious lifecycle operations such as deleting storage files, starting/stopping tunnels, canceling jobs, or managing users and teams beyond lookup/read.
Maintenance
Related MCP Connectors
Direct access to Cypress tests results and accessibility reports in your AI workflow.
Run, debug, and triage tests from your IDE using natural language, no dashboard switching, no manual data transfers. The TestMu AI (formerly LambdaTest) MCP Server is a single remote server exposing four tool suites: HyperExecute — analyze your project, generate YAML configs and test runner commands, then monitor jobs and sessions. Automation — pull a TestID's details plus command, network, and console logs into one chat for instant root-cause analysis. Includes mobile app upload. SmartUI — explain pixel, layout, DOM, and perceptual changes in a visual regression run, with context-aware React/HTML/CSS fixes. Accessibility — audit any public URL or a local React app against WCAG and get ready-to-apply remediation steps. Connects over https://mcp.lambdatest.com/mcp using OAuth 2.1 — no API keys in your config. One-click install in Cursor; works with Claude, GitHub Copilot, Cline, and any MCP client. Tests execute on the TestMu AI cloud: 3,000+ browsers and 10,000+ real devices.
Agentic AI quality engineering: run, debug and triage tests on real browsers and devices
Read your runners.io organisation's jobs, logs, test results, cache and spend from an AI agent.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to interact with Jenkins CI/CD systems for build management, job monitoring, console log analysis, and debugging through natural language commands.2MIT

MCP Appiumofficial
AlicenseAqualityAmaintenanceEnables AI assistants to automate mobile app testing and development for iOS and Android through natural language interactions. Supports intelligent element identification, session management, automated test generation, and comprehensive device interactions including clicks, swipes, screenshots, and app management.3210,260 npm519Apache 2.0
SmartBear MCP serverofficial
AlicenseAqualityBmaintenanceEnables AI assistants to interact with SmartBear's suite of testing and monitoring tools including BugSnag, Swagger, Reflect, and more through natural language, allowing querying of testing data, analysis of performance metrics, and management of test automation.118,218 npm44MIT- AlicenseNot gradedqualityDmaintenanceEnables AI models (Claude, ChatGPT, GitHub Copilot) to run and analyze local tests, rerun failures, and orchestrate QA workflows using existing UI and API test frameworks.13 npmMIT