# Connecting AI Assistants to Loadster (MCP)

> Connect Claude, ChatGPT, Cursor, Codex, and other AI assistants to the Loadster MCP server to write and play scripts, build load tests, and read results.

Source: https://loadster.com/manual/mcp/

Your favorite AI assistants (like Claude, ChatGPT, Cursor, and others) can communicate directly with Loadster.

Assistants can speed up the slow parts of load testing and monitoring for you: writing and playing scripts, building load
test scenarios, setting up monitors, and analyzing test results. You describe the flow you want to test, and the assistant
builds it in your Loadster project using the same tools you'd use in the dashboard.

It works best if your assistant knows your application or site already, taking advantage of that context to speed up
your testing. Run the assistant from a project with as much of that context available as possible.

The way this works under the hood is through Loadster's [Model Context Protocol](https://modelcontextprotocol.io/) (MCP)
server. MCP is the open standard that AI assistants can use to call external tools, and Loadster's MCP server (at
`https://api.loadster.com/mcp`) exposes the script editor, scenarios, monitors, and results. Compatible clients must
support remote servers over Streamable HTTP and authenticate with OAuth or an `Authorization: Bearer` header.

## What Your AI Assistant Can Do with Loadster

The MCP server gives your assistant access to many of the capabilities in the Loadster dashboard.

- **Scripts**: create, edit, validate, and play Protocol Bot, Browser Bot, and Playwright scripts. After a play, the
  assistant can inspect each step's results, response bodies, captured values, logs, and even screenshots from real browser
  plays.
- **Datasets**: create and update [datasets](https://loadster.com/manual/dynamic-datasets/) to feed test data into scripts.
- **Scenarios**: create and configure [load test scenarios](https://loadster.com/manual/load-test-scenarios/), choosing bot groups, ramp
  patterns, and regions.
- **Load test reports**: read the results of finished load tests, dig into the numbers, and add notes.
- **Monitoring**: create and manage [monitors](https://loadster.com/manual/monitoring/), review monitor cycles, and investigate incidents.

Some actions are intentionally left to humans. An assistant cannot launch or stop a full load test, enable a monitor, manage
notification policies or maintenance windows, or administer your team, billing, or Fuel.

Your assistant can get everything ready and then hand it off so you push the launch button.

## How Your Assistant Authenticates

There are two ways to connect to the Loadster MCP: OAuth and personal access tokens.

### Authenticating with OAuth

Clients with MCP OAuth support send you to Loadster to approve the connection in your browser, either when you install
the Loadster plugin (in ChatGPT and Codex) or when you point them at the server URL (in Claude Code, Cursor, and others).
If your tool supports OAuth it's generally the preferred way.

There's no token to copy, and you can see and revoke connected assistants on the **API & Agents** page in your Loadster
settings. Later, we'll show how to initiate the connection for several of the leading tools.

### Authenticating with Personal Access Tokens

If your tool doesn't support OAuth, you'll need to create a personal access token and use that instead. The same kind
of token also works for calling the [Loadster REST API](https://loadster.com/manual/rest-api/) directly.

1. In the Loadster dashboard, go to **Settings → API & Agents → Personal Access Tokens**.
2. Give the token a name (like "Claude Code") and create it.
3. Copy the token right away, since it's only shown once.

Each token acts on your behalf within your team, so treat it like a password. You can revoke a token at any time from
the same page, and any assistant using it immediately loses access.

### AI Assistants on Teams That Require Two-Factor Authentication

If your team requires two-factor authentication and you haven't set it up yet, your OAuth connections and personal
access tokens stop working until you do. An assistant that reconnects through OAuth sends you to the Loadster dashboard,
which asks you to set up two-factor authentication before approving the connection. Your existing connections and
tokens work again as soon as you've set it up.

## Connecting Claude Code to Loadster

The quickest way is the Loadster plugin, which adds the MCP server along with a few skills that walk Claude through a
sensible load testing workflow:

```text
/plugin marketplace add loadster/loadster-mcp
/plugin install loadster@loadster
```


Then run `/mcp`, choose **loadster**, and approve the Loadster OAuth connection in your browser.

If you'd rather add just the server, one command does it, and Claude Code will walk you through signing in to Loadster
with OAuth:

```bash
claude mcp add --transport http loadster https://api.loadster.com/mcp
```


For headless use, or if you prefer a personal access token, pass it as a header instead:

```bash
claude mcp add --transport http loadster https://api.loadster.com/mcp --header "Authorization: Bearer YOUR_TOKEN"
```


Or, if you prefer a project-level `.mcp.json` file:

```json
{
  "mcpServers": {
    "loadster": {
      "type": "http",
      "url": "https://api.loadster.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}
```


Then ask Claude something like _"List my Loadster projects"_ to make sure the connection works.

_These instructions worked when this page was last reviewed. If they no longer match what you see, check the client's
official MCP documentation and email [help@loadster.com](mailto:help@loadster.com) so we can update this page._

## Connecting ChatGPT to Loadster

Loadster is an official plugin in the ChatGPT plugin directory. Along with the connection itself, the plugin adds three
skills that walk ChatGPT through a sensible workflow: `load-test` for building and checking a load test, `results` for
reading test reports and monitor incidents, and `setup` for checking the connection.

1. Open the [Loadster plugin](https://chatgpt.com/plugins/plugin_asdk_app_6aa2109570b0819194170aae3449f6fb) in ChatGPT, or open **Plugins** from the sidebar and search for Loadster.
2. Select **Install plugin**.
3. When prompted, select **Connect** and approve the Loadster OAuth connection in your browser.
4. Start a conversation with **@Loadster** and your request, or pick Loadster from **+ → More**.

On a ChatGPT Business or Enterprise workspace, an admin may need to make Loadster available under
**Workspace settings → Plugins** before you can install it.

The plugin works in your real Loadster account, and Loadster writes are real, so keep experiments in their own project.

### Connecting ChatGPT to Loadster in Developer Mode

If the Loadster plugin isn't available on your account, you can add Loadster as a custom connection in Developer mode
instead, where your account and workspace policy allow it.

1. In ChatGPT, open **Settings → Security and login** and turn on **Developer mode**.
2. Open **Plugins**, select the plus button, and enter a name and description for the connection.
3. Under **Connection**, enter the Loadster MCP URL: `https://api.loadster.com/mcp`.
4. Create the connection, then start a new conversation, add the Loadster connection from the tools menu, and approve
   the Loadster OAuth connection when prompted.

If you change or add tools later, refresh the connection under **Plugins** and start another new conversation.

_These instructions worked when this page was last reviewed. If they no longer match what you see, check the client's
official MCP documentation and email [help@loadster.com](mailto:help@loadster.com) so we can update this page._

## Connecting Codex to Loadster

The Loadster plugin is in the Codex plugin directory too, with the same skills.

- In the Codex desktop app, open the **Plugins** tab, find Loadster, and install it.
- In the Codex CLI, run `/plugins`, find Loadster, and install it, then start a new session.

Approve the Loadster OAuth connection in your browser when Codex asks. In a Codex task, you can also choose Loadster
from **Sources → Use plugins**.

The Codex IDE extension doesn't support plugins, so it connects through Codex's MCP server configuration instead. The
desktop app and CLI can use that configuration too, which is handy if you'd rather use a personal access token than OAuth.

### Adding Loadster to Codex Desktop as an MCP Server

The Codex desktop app shares its MCP configuration with the Codex CLI and IDE extension on the same Codex host.

1. Open **Settings → MCP servers**.
2. Select **Add server**, name it `loadster`, and choose **Streamable HTTP**.
3. Enter `https://api.loadster.com/mcp` as the URL, save the server, and select **Restart**.
4. If the server list says authentication is required, select **Authenticate** and approve the Loadster OAuth connection
   in your browser.
5. Start a new Codex task and type `/mcp` in the composer to confirm that Loadster is connected.

The desktop app, CLI, and IDE extension all use `~/.codex/config.toml` by default. You can also put the configuration in
a trusted project's `.codex/config.toml` if you want it available only in that project.

### Adding Loadster to the Codex CLI as an MCP Server

For OAuth, add Loadster and then sign in:

```bash
codex mcp add loadster --url https://api.loadster.com/mcp
codex mcp login loadster
```


Start a new Codex session and run `/mcp` to confirm the Loadster tools are connected.

If you prefer a personal access token, create one under **Settings → API & Agents → Personal Access Tokens**, make it
available to the Codex process as an environment variable, and add the server with that variable's name:

```bash
export LOADSTER_MCP_TOKEN="YOUR_TOKEN"
codex mcp add loadster --url https://api.loadster.com/mcp --bearer-token-env-var LOADSTER_MCP_TOKEN
```


The equivalent `config.toml` entry is:

```toml
[mcp_servers.loadster]
url = "https://api.loadster.com/mcp"
bearer_token_env_var = "LOADSTER_MCP_TOKEN"
```


Make sure `LOADSTER_MCP_TOKEN` is set in the environment before starting Codex. OAuth is usually easier in the desktop
app because an app launched from the Dock or Start menu may not inherit variables from your shell.

See OpenAI's [plugin](https://learn.chatgpt.com/docs/plugins) and [MCP](https://learn.chatgpt.com/docs/extend/mcp)
documentation for the latest Codex client details.

_These instructions worked when this page was last reviewed. If they no longer match what you see, check the client's
official MCP documentation and email [help@loadster.com](mailto:help@loadster.com) so we can update this page._

## Connecting Cursor to Loadster

Cursor supports OAuth for remote MCP servers, so the one-click install link is usually all you need:
[Add Loadster to Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=loadster&config=eyJ1cmwiOiJodHRwczovL2FwaS5sb2Fkc3Rlci5jb20vbWNwIn0=).

Or add the server to `.cursor/mcp.json` in your project (or `~/.cursor/mcp.json` for all projects), starting with just
the Loadster URL:

```json
{
  "mcpServers": {
    "loadster": {
      "url": "https://api.loadster.com/mcp"
    }
  }
}
```


When Cursor connects for the first time, approve the Loadster OAuth connection in your browser. You can then find and
enable the server under **Customize** in Cursor.

To use a personal access token instead, set `LOADSTER_MCP_TOKEN` in the environment before starting Cursor and add an
authorization header with Cursor's environment-variable interpolation:

```json
{
  "mcpServers": {
    "loadster": {
      "url": "https://api.loadster.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:LOADSTER_MCP_TOKEN}"
      }
    }
  }
}
```


See [Cursor's MCP documentation](https://cursor.com/docs/mcp) for the latest configuration details.

_These instructions worked when this page was last reviewed. If they no longer match what you see, check the client's
official MCP documentation and email [help@loadster.com](mailto:help@loadster.com) so we can update this page._

## Connecting VS Code to Loadster

You can run **MCP: Add Server** from the Command Palette and choose a workspace or global installation. To configure a
workspace manually, add the server to `.vscode/mcp.json`. Use an input variable so the token isn't stored in the file:

```json
{
  "inputs": [
    {
      "type": "promptString",
      "id": "loadster-mcp-token",
      "description": "Loadster personal access token",
      "password": true
    }
  ],
  "servers": {
    "loadster": {
      "type": "http",
      "url": "https://api.loadster.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:loadster-mcp-token}"
      }
    }
  }
}
```


Start or restart the server from the inline actions in `mcp.json`, or run **MCP: List Servers** from the Command
Palette. The first time it starts, VS Code prompts for the token and stores it securely. Review the configuration and
confirm that you trust the server when asked; otherwise its tools won't be available in chat.

See [VS Code's MCP documentation](https://code.visualstudio.com/docs/agent-customization/mcp-servers) for the latest
configuration details.

_These instructions worked when this page was last reviewed. If they no longer match what you see, check the client's
official MCP documentation and email [help@loadster.com](mailto:help@loadster.com) so we can update this page._

## Connecting Claude Desktop to Loadster

Claude Desktop and claude.ai connect to remote MCP servers as custom connectors, which use OAuth. Custom connectors are
available on every plan, including the free plan, which allows one. Claude Desktop does not use
`claude_desktop_config.json` for remote servers, so there is nothing to edit on your computer.

1. In Claude, open **Settings → Connectors** and choose **Add custom connector**.
2. Enter a name and the Loadster MCP URL: `https://api.loadster.com/mcp`.
3. Add the connector, then choose **Connect** and approve the Loadster OAuth connection when your browser opens.
4. In a conversation, open the tools menu and turn on the Loadster connector.

_These instructions worked when this page was last reviewed. If they no longer match what you see, check the client's
official MCP documentation and email [help@loadster.com](mailto:help@loadster.com) so we can update this page._

## Connecting Other MCP Clients

Any MCP client that supports remote servers over streamable HTTP can connect the same way: the endpoint is
`https://api.loadster.com/mcp`, and it authenticates with OAuth, or with a personal access token in an
`Authorization: Bearer` header if the client can't do OAuth.

A few clients only support local (stdio) servers, or don't have a place to enter a custom header. For those, the
[mcp-remote](https://www.npmjs.com/package/mcp-remote) bridge usually works as a local command. Leave out the two
`--header` arguments to have it run the OAuth flow instead of using a token:

```json
{
  "mcpServers": {
    "loadster": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.loadster.com/mcp", "--header", "Authorization: Bearer YOUR_TOKEN"]
    }
  }
}
```


## Loadster MCP on GitHub and in MCP Directories

The [loadster/loadster-mcp](https://github.com/loadster/loadster-mcp) repository on GitHub is the public home for
connecting to the Loadster MCP server. It has the same setup snippets as this page, the Claude Code plugin, and the
metadata behind Loadster's listings in MCP directories, including the `server.json` for the official MCP Registry under
the name `com.loadster/loadster-mcp`. The server itself is hosted by Loadster, so there's nothing to install or run
from the repository, and its source isn't published there.

Loadster is also an official plugin in the [ChatGPT and Codex plugin directory](https://chatgpt.com/plugins/plugin_asdk_app_6aa2109570b0819194170aae3449f6fb), with the same
`load-test`, `results`, and `setup` skills as the Claude Code plugin.

If a snippet on this page and one in the repository ever disagree, this page is the one we keep current, and we'd
appreciate an email to [help@loadster.com](mailto:help@loadster.com) so we can fix the other.

## AI Load Testing Safety Practices

There are a few things worth knowing before you turn an assistant loose on your projects. They are probably common sense,
but worth thinking about all the same.

- **The assistant will do things in your Loadster account.** Assistants edit the same scripts, scenarios, datasets, and monitors
  your team sees in the dashboard. Loadster marks destructive operations for MCP clients, but whether you see an
  approval prompt depends on the client and its settings. Script changes create revisions you can restore, but it's
  still a good idea to review proposed changes and keep experiments in their own project.
- **Only test what's yours.** As always, point your scripts only at systems you own or are authorized to test. Playing a
  script runs just one bot, but it's your responsibility either way.
- **Scope your access.** Create a separate token per assistant or machine, name them clearly, and revoke any you no longer
  use. For OAuth connections, review the connected assistants on the **API & Agents** page and revoke any you don't
  recognize. If you belong to more than one team, note that access is tied to the team you connected in.
- **You're responsible for what your assistant does.** Loadster doesn't run the AI assistants themselves, so whatever your assistant
  of choice does in Loadster is equivalent to you doing it yourself. Assistant behavior and approval defaults vary, so
  review requested changes and any destructive-action prompts carefully.
- **Using the Loadster MCP consumes your assistant's usage and tokens.** Like anything your assistant does, using the Loadster
  MCP consumes some of its usage limits or tokens, so keep an eye on your usage with the provider.

## Data Handling and Privacy for the Loadster MCP

One reason we built an MCP server, instead of baking an AI assistant into Loadster, is so you can keep your
conversations with your AI assistant private. Your prompts and the back-and-forth conversation between you and your assistant
stay with your AI provider (Anthropic, OpenAI, Microsoft, or whoever) and never reach Loadster. Only the actions your
assistant actually takes with the Loadster platform become visible to us, much like when a person uses the Loadster
dashboard.

So if your organization is reviewing whether data submitted through a tool like Microsoft Copilot could be persisted or
processed outside your provider's tenant boundary, the short version is that Loadster only ever receives the MCP tool
calls, not the chat conversation that produced them.

### What the Loadster MCP Server Receives

The MCP server receives and processes **tool calls and their parameters** — the specific actions your assistant asks
Loadster to perform, like creating a script, playing it, or updating a scenario. Loadster does not receive your prompts
or your conversation with the assistant. In short, Loadster sees what your assistant does on the platform, not what you and your
assistant discussed to get there.

For each MCP tool call, we log the timestamp, the name of the tool, and certain parameters. These logs are retained for
a reasonable period so we can understand how the MCP is being used and help troubleshoot any problems you run into.

### How MCP Log Data Is Used

Loadster does not use your data for AI or machine-learning model training, and as noted above we never see your prompts.
The high-level tool-call records in our logs may be used for analytics, diagnostics and troubleshooting, support, and
product improvement (pretty much the same kinds of operational purposes we'd use any usage logs for).

### Tenant Isolation and Data Segregation

Your data stays logically segregated by team, just as it does everywhere else in Loadster, and the MCP doesn't change
this. An assistant connects on behalf of a single team and can only reach that team's projects, scripts, datasets,
scenarios, and results. See [How Your Assistant Authenticates](#how-your-assistant-authenticates) for how that access is scoped.

### Sub-processors for MCP Functionality

Providing the MCP functionality doesn't introduce any new sub-processors. The MCP server is built directly into
Loadster's own backend, so tool calls are handled by the same infrastructure that already runs the platform. For our
overall data practices, see the [privacy policy](https://loadster.com/legal/privacy/).

## Troubleshooting AI Assistant Connections

Once connected, assistants are pretty good at figuring things out, but here are a few potential problems.

- **401 or unauthorized errors**: an initial unauthenticated 401 in server logs can be a normal part of OAuth discovery.
  A 401 shown to the user, or repeated after OAuth completes, usually means a token is missing, mistyped, or revoked, or
  the OAuth connection was revoked. Check the `Authorization: Bearer` header and mint a fresh token, or reconnect over
  OAuth.
- **The assistant can't find a project or script**: access is scoped to the team you connected in. Ask the assistant to call
  `list_projects` and check that the right team's projects come back.
- **Tools seem stale or missing**: some clients cache the tool list per session. In ChatGPT, start a new conversation,
  and if you connected in Developer mode, refresh the connection under **Plugins** first. In Codex, start a new session
  or task, and restart the desktop app after saving MCP settings. Codex can take up to 6 hours to pick up a new version
  of the Loadster plugin.

If you get stuck, email [help@loadster.com](mailto:help@loadster.com) and we'll help you out.

