BlazeMeter API Test MCP server

The BlazeMeter API Test MCP server connects AI tools directly to cloud-based BlazeMeter API Testing & Monitoring platform (Runscope).

This gives AI agents, assistants, and chatbots the ability to read and manage teams, buckets and tests, analyze test and its results, and automate workflows all through natural language interactions.

In this topic:

Use cases

The BlazeMeter API Test MCP server is built for developers and QA teams who want to connect their AI tools to API Monitoring's enterprise-grade testing capabilities, from simple test creation to complex multi-step automation workflows. Through MCP integration, developers can perform:

Team operations

  • List all teams the user is a member of to establish the organizational context.

  • Retrieve details of a specific team, including team ID, name, and associated permissions.

  • This serves as the root entity for all downstream resources such as buckets, tests, and results.

Bucket management

  • List all buckets belonging to a team.

  • Retrieve a specific bucket by ID or name to inspect its metadata and structure.

  • Create new buckets to organize API tests under logical projects or services.

  • Run bucket-level test suites, executing all tests defined within the bucket and retrieving their aggregated results.

Test management

  • List all tests within a bucket to get visibility into available API tests.

  • Retrieve a single test by ID or name to view its configuration, steps, and environment references.

  • Create new tests programmatically via MCP tools for automation or migration workflows.

  • Run an individual test and obtain its execution results, including pass/fail status and timestamps.

Test scheduling management

  • Create a new test schedules to automate test execution at predefined intervals.

  • View existing schedules to manage or audit automated test runs.

  • Retrieve associated schedules for a test to understand its execution context and frequency.

Test step management

  • List all steps within a test to understand its workflow and structure.

  • Retrieve a single step’s details to inspect API request/response configuration, conditions, and validations.

  • Create a new test step (Pause or Request) to modify or extend test workflows.

Install BlazeMeter API Test MCP server

You can deploy the BlazeMeter API Test MCP server locally.

Prerequisites

  • BlazeMeter API Monitoring Access Token

  • Compatible MCP host (VS Code, Claude Desktop, Cursor, Windsurf, etc.)

  • Docker (only for Docker-based deployment)

  • uv (a high-performance Python package) and Python 3.11+. Both required only for installation from source code distribution.

  • API Monitoring's AI-assisted features require account owner consent. For more information, see Manage AI Consent.

The installation options are as follows:

  • Installation using our interactive CLI tool

  • Manual client configuration, either through binary installation or from remote source code

  • Docker MCP client configuration

Configure MCP client with the CLI tool

The simplest way to configure your MCP client is using the interactive CLI tool:

  1. From the Releases page, download the appropriate binary file for your operating system. Select the binary that matches your OS (Windows, macOS, Linux).

  2. Execute or double-click the binary to launch the interactive configuration tool.

The tool automatically generates the MCP JSON Key configuration for you.

For macOS, you may encounter a security alert "Apple could not verify 'mcp-bzm-apitest-darwin' is free of malware."

To resolve this issue:

  1. Go to System Settings, Privacy & Security, Security.

  2. Locate the blocked application and click Allow Anyway.

  3. Run the binary again.

Configure MCP client manually (binary installation)

  1. From the Releases page, download the binary for your operating system.

  2. Configure your MCP client with the following settings:

Copy 
{
  "mcpServers": {
    "BlazeMeter API Test MCP": {
      "command": "/path/to/mcp-bzm-apitest-binary",
      "args": ["--mcp"],
      "env": {
        "BZM_API_TEST_TOKEN_FILE": "/path/to/your/bzm_api_test_token.env"
      }
    }
  }
}

Configure MCP client manually (from remote source code)

  1. Install uv and Python 3.11+.

  2. Configure your MCP client with the following settings:

Copy 
{
  "mcpServers": {
    "BlazeMeter API Test MCP": {
      "command": "uvx",
      "args": [
        "--from", "git+https://github.com/Runscope/mcp-bzm-apitest.git@v1.0.0",
        "-q", "mcp-bzm-apitest", "--mcp"
      ],
      "env": {
        "BZM_API_TEST_TOKEN_FILE": "/path/to/your/bzm_api_test_token.env"
      }
    }
  }
}

The uvx installs and runs the package and its dependencies in a temporary environment. You can change to any version that has been released or any branch you want. Package support for uvx command is supported from version 1.0.1 onwards. For more information on the uv/uvx arguments used, see the official uv documentation.

Configure MCP client for Docker

Use the following settings:

Copy 
{
  "mcpServers": {
    "Docker BlazeMeter API Test MCP": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "BZM_API_TEST_TOKEN=your_api_token",
        "ghcr.io/blazemeter/mcp-bzm-apitest:latest"
      ]
    }
  }
}

Configure custom CA certificates for Docker (corporate environments)

Use custom Certificate Authority (CA) certificates in Docker when one or more of the following conditions apply:

  • Your organization uses self-signed certificates

  • You're behind a corporate proxy that performs SSL inspection

  • Your environment includes a custom CA

  • You encounter SSL certificate verification errors during test execution

Custom CA certificate bundles require the following configuration:

  • Certificate Volume Mount: Mount your custom CA certificate bundle into the container

  • SSL_CERT_FILE Environment Variable: Explicitly set the SSL_CERT_FILE environment variable to point to the certificate location inside the container

Example configuration:

Copy 
{
  "mcpServers": {
    "Docker BlazeMeter API TEST MCP": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "SSL_CERT_FILE=/etc/ssl/certs/custom-ca-bundle.crt",
        "-e",
        "BZM_API_TEST_TOKEN=your_api_token",
        "ghcr.io/blazemeter/mcp-bzm-apitest:latest"
      ]
    }
  }
}

In the above example, replace:

  • /path/to/your/ca-bundle.crt with your host system's CA certificate file path

  • The container path /etc/ssl/certs/custom-ca-bundle.crt with any path you prefer (ensure it matches SSL_CERT_FILE)

The SSL_CERT_FILE environment variable must be set to point to your custom CA certificate bundle. The httpx library automatically respects the SSL_CERT_FILE environment variable for SSL certificate verification.

Server tools

The following tools are available with the BlazeMeter API Test MCP server.

  • blazemeter_apitest_teams

    • List teams within your BlazeMeter account

    • Read team details

    • Get a list of all team users

  • blazemeter_apitest_buckets

    • List all the buckets

    • Read bucket details

    • Create a new bucket

  • blazemeter_apitest_tests

    • List all API tests within a bucket

    • Read test details

    • Create a new API test

    • Get the test metrics

  • blazemeter_apitest_schedules

    • List all schedules within a test

    • Read schedule details

    • Create a new schedule

  • blazemeter_apitest_steps

    • List all steps within a test

    • Read test step details

    • Add a new Pause and Request step (with URL, Method, Body and Assertions) to a test

  • blazemeter_apitest_environments

    • List all test environments

    • Read test environment details

  • blazemeter_apitest_results

    • Execute an individual test or all bucket-level tests

    • List last 50 test results

    • Read test result and bucket-level result details

Notes

  • This project is licensed under the Apache License, Version 2.0.

  • To ensure the security of your MCP clients, never share API tokens, use the token in an .env file rather than directly in environment variables, and keep your .env files secure and private.