Skip to main content
Glama
Sauce Labs MCP Server

Sauce Labs MCP Server

Official
by saucelabs

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.

TIP

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-rdc auto-discovers the latest RDC v2 endpoints from the OpenAPI spec at startup; the cached spec is used as a fallback when the network is unavailable

  • Response 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+

  • pip

  • Sauce 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-mcp

This installs both servers and registers their command-line entry points:

  • sauce-api-mcp — core server

  • sauce-api-mcp-rdc — RDC OpenAPI server

Verify installation:

which sauce-api-mcp
which sauce-api-mcp-rdc

Configuration for LLM Clients

Claude Desktop (Mac / Linux / Windows)

  1. Locate your Claude Desktop config file:

    • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

    • Windows: %APPDATA%\Claude\claude_desktop_config.json

    • Linux: ~/.config/Claude/claude_desktop_config.json

  2. Find your Python installation's bin directory:

    python3 -c "import sys; print(sys.prefix + '/bin')"
  3. 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"
          }
        }
      }
    }
  4. 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: stdio

Environment 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

SAUCE_USERNAME

Your Sauce Labs username

SAUCE_ACCESS_KEY

Your Sauce Labs access key (found in Account Settings)

Optional Environment Variables

Variable

Default

Description

SAUCE_REGION

US_WEST

Data centre region: US_WEST, US_EAST, EU_CENTRAL

SAUCE_MCP_MAX_RESPONSE_ITEMS

100

Maximum list items returned before truncation (RDC server)

Getting Your Sauce Labs Credentials

  1. Log into your Sauce Labs account

  2. Navigate to Account → User Settings

  3. 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:

  1. 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 just which sauce-api-mcp

  2. Module 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

get_account_info

Retrieve current user account information

lookup_users

Find users in your organisation

get_user

Get detailed user information

lookup_teams

Find teams in your organisation

get_team

Get team details

list_team_members

List all members of a specific team

lookup_service_accounts

List service accounts

get_service_account

Get service account details

get_my_active_team

Get the active team for the authenticated user

Device Management

Tool

Description

get_devices_status

List all devices and their current status

get_specific_device

Get detailed information about a specific device

get_private_devices

List private devices available to your account

Test Jobs

Tool

Description

get_recent_jobs

Retrieve your most recent test jobs

get_job_details

Get comprehensive details about a specific job

get_real_device_jobs

List active jobs on real devices

get_specific_real_device_job

Get details about a specific real device job

get_specific_real_device_job_asset

Download job assets (logs, videos, screenshots)

Builds

Tool

Description

lookup_builds

Search for builds with filters

get_build

Get detailed information about a specific build

get_build_for_job

Get the build associated with a job

lookup_jobs_in_build

List all jobs within a build

Storage

Tool

Description

get_storage_files

List uploaded application files

get_storage_groups

List app storage groups

get_storage_groups_settings

Get settings for a storage group

upload_file_to_storage

Upload an app file to Sauce Storage

update_storage_group_settings

Update app group settings (resigning, instrumentation, etc.)

Tunnels

Tool

Description

get_tunnels_for_user

List active Sauce Connect tunnels

get_tunnel_information

Get details about a specific tunnel

get_current_jobs_for_tunnel

See how many jobs are using a tunnel

get_tunnel_version_downloads

Get download URLs for Sauce Connect versions

Test Assets & Logs

Tool

Description

get_test_assets

Retrieve test artifacts for a VDC job

get_log_json_file

Get structured test execution logs for a VDC job

get_network_har_file

Get HAR network capture data with filtering

filter_har_data

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

createSession

Allocate a real device and return an ACTIVE session. Polls until ACTIVE or times out (~55 s)

listSessions

List current device sessions with optional filtering

deleteSession

Close a session and release the device back to the pool

get_session_details

Get full details of a specific session

Device Discovery

Tool

Description

listDevices

Browse the full device catalogue with OS/model filters

list_device_status

Get live availability status of devices

App Management

Tool

Description

installApp

Start an app installation on a device (returns an installation ID)

waitForAppInstallation

Poll installation status — call repeatedly until FINISHED

launchApp

Launch an already-installed app

uninstallApp

Remove an app from a device

list_app_installations

List ongoing or recent app installations

install_app_from_storage

Install an app from Sauce Storage

Device Interaction

Tool

Description

take_screenshot

Capture the current device screen

open_url_or_deeplink

Open a URL or deep link on the device

execute_shell_command

Run an adb shell command (Android)

applyDeviceSettings

Change device settings (orientation, locale, etc.)

File Operations

Tool

Description

push_file_to_device

Upload a local file to the device (restricted to ~/.sauce-mcp/files/)

pull_file_from_device

Download a file from the device

listFiles

List files in a device directory

removeFile

Delete a file from the device

statFile

Get metadata about a file or directory on the device

Network & Proxy

Tool

Description

proxy_http

Forward HTTP requests through the device proxy

startNetworkCapture / stopNetworkCapture

Capture network traffic

setNetworkProfile / setNetworkConditions

Simulate network conditions

listNetworkProfiles

List available network profiles

resetNetworkConditions

Restore normal connectivity

Appium

Tool

Description

startAppiumServer

Start a hosted Appium server co-located with the device

getAppiumServerStatus

Check if Appium is running and get its endpoint URL

listAppiumVersions

List available Appium versions

launchWebDriverAgent

Launch WDA on an iOS device

getWebDriverAgentStatus

Check WDA status

Development Setup

Prerequisites

  • Python 3.10+

  • uv package manager

  • Git

Clone and Setup

git clone https://github.com/saucelabs/sauce-api-mcp.git
cd sauce-api-mcp
uv sync

This 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 dependencies

Running the Servers Locally

uv run sauce-api-mcp
uv run sauce-api-mcp-rdc

Both 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 pytest

Adding Dependencies

uv add httpx
uv add --dev pytest-asyncio

CI / Release Workflow

Continuous Integration

Every pull request targeting main runs three sequential jobs via build.yml:

  1. test — integration tests across Python 3.10, 3.11, 3.12 (in parallel)

  2. test-live — live tests on Python 3.12 (after test)

  3. 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:

  1. Go to Actions → Release → Run workflow

  2. Choose the release type: patch, minor, major, or prerelease

  3. For pre-releases, optionally set the token (alpha, beta, rc)

The workflow then:

  • Bumps the version in pyproject.toml and server.json using python-semantic-release

  • Creates a v* git tag and a GitHub Release with auto-generated changelog

  • Publishes 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

Changelog

For a full history of releases and changes, see the GitHub Releases page.

v1.1.0

  • Merged sauce-api-mcp and sauce-labs-mcp (RDC OpenAPI) into single monorepo package

  • Added sauce-api-mcp-rdc entry point for the RDC-focused server

  • Migrated RDC server from deprecated FastMCPOpenAPI to OpenAPIProvider + FastMCP (fastmcp 3.x)

  • Automated release workflow via workflow_dispatch with python-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.lock for 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 tools
filter_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

    B3.1/5.0

    Scored across 34 tools

    Disambiguation3/5

    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.

    Naming Consistency4/5

    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.

    Tool Count2/5

    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.

    Completeness3/5

    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

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      A
      maintenance
      Enables 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.
      32
      10,260 npm
      519
      Apache 2.0
    • A
      license
      A
      quality
      B
      maintenance
      Enables 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.
      1
      18,218 npm
      44
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables 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 npm
      MIT