QA Spider MCP server: fix your site from Cursor, Claude and Codex

Custom connectors work in claude.ai, Claude Desktop and the mobile apps through your Claude account.

1. Individual plans: open Customize, then Connectors, press + Add and choose Add custom connector. On Team and Enterprise, an owner adds it under Organization settings, Connectors, Add, Custom, Web.
2. Name it QA Spider and paste the address: https://www.qaspider.com/api/mcp
3. Press Connect and sign in with your QA Spider account, then choose the team and the permissions on the consent screen.
4. Prefer a key? Under Request headers add one fixed header, Authorization with the value shown below.

https://www.qaspider.com/api/mcp

Authorization: Bearer qsp_YOUR_KEY

Claude connects from Anthropic’s cloud, not from your computer, so the server must be reachable from the internet. QA Spider is.

Free Claude accounts can add one custom connector.

The claude_desktop_config.json file is a separate mechanism for local servers; use the connector screen for a remote one.

Checked against the vendor’s documentation.

ChatGPT on the web can use a remote MCP server as a developer-mode app.

1. In ChatGPT on the web, turn on Developer mode (Settings, Security and login), then create an app from the plugins screen with the + button. OpenAI renames these screens often; the vendor page below has the current names.
2. Choose a remote MCP server and paste the address: https://www.qaspider.com/api/mcp
3. Choose OAuth as the authentication, then sign in with your QA Spider account and pick the team and permissions.
4. The new app appears under Drafts, where you can switch individual tools on or off.

https://www.qaspider.com/api/mcp

Available on the web for Pro, Plus, Business, Enterprise and Education accounts.

OpenAI’s documentation lists OAuth or no authentication for these apps, not a bearer key, so use the sign-in here.

ChatGPT asks you to confirm any tool that is not marked read-only.

Checked against the vendor’s documentation.

Anthropic’s coding agent for the terminal and the IDE.

1. Run the add command below in your terminal.
2. Start Claude Code and type /mcp. Choose qaspider and follow the browser sign-in, then pick the team and permissions.
3. Prefer a key? Use the second command instead, with the key from your dashboard.

claude mcp add --transport http qaspider https://www.qaspider.com/api/mcp

claude mcp add --transport http qaspider https://www.qaspider.com/api/mcp \
  --header "Authorization: Bearer qsp_YOUR_KEY"

{
  "mcpServers": {
    "qaspider": {
      "type": "http",
      "url": "https://www.qaspider.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${QASPIDER_KEY}"
      }
    }
  }
}

Add --scope user to make it available in every project, or --scope project to write .mcp.json for your team. The default is local to the current project.

.mcp.json expands ${VAR}, so commit the file and keep the key in your shell environment.

Checked against the vendor’s documentation.

The Codex CLI, IDE extension and ChatGPT desktop app share one config file.

1. Open ~/.codex/config.toml and add the block below.
2. With a key: export QASPIDER_KEY=qsp_YOUR_KEY in the shell that starts Codex. Codex sends it as the bearer token.
3. With sign-in: keep only the url line, then run the login command and approve the browser sign-in.

[mcp_servers.qaspider]
url = "https://www.qaspider.com/api/mcp"
bearer_token_env_var = "QASPIDER_KEY"

[mcp_servers.qaspider]
url = "https://www.qaspider.com/api/mcp"

codex mcp login qaspider

Codex uses dynamic client registration when the server offers it, which QA Spider does.

Checked against the vendor’s documentation.

Google’s open-source terminal agent. Remote servers use httpUrl.

1. Run the command below, or add the entry to ~/.gemini/settings.json (user) or .gemini/settings.json (project).
2. Use a connection key: Gemini CLI’s documentation shows headers for this, and OAuth only with a client id you register yourself.

gemini mcp add --transport http -H "Authorization: Bearer qsp_YOUR_KEY" qaspider https://www.qaspider.com/api/mcp

{
  "mcpServers": {
    "qaspider": {
      "httpUrl": "https://www.qaspider.com/api/mcp",
      "headers": {
        "Authorization": "Bearer qsp_YOUR_KEY"
      }
    }
  }
}

The settings file holds your key in plain text. Use the user-level file, not one inside a repository.

Checked against the vendor’s documentation.

The Warp terminal’s agents can use URL-based MCP servers.

1. Open Settings, Agents, MCP servers (or search “Open MCP Servers” in the Command Palette) and press + Add.
2. Choose a Streamable HTTP or SSE server (URL) and paste the JSON below.

{
  "qaspider": {
    "url": "https://www.qaspider.com/api/mcp",
    "headers": {
      "Authorization": "Bearer qsp_YOUR_KEY"
    }
  }
}

Warp’s documentation describes browser sign-in for servers with built-in OAuth; use the key if it does not start.

Checked against the vendor’s documentation.

The AI code editor. One file holds every MCP server.

1. Open ~/.cursor/mcp.json to use QA Spider in every project, or .cursor/mcp.json inside one project.
2. Add the entry below. Cursor reads ${env:NAME} from your environment, so the key never goes in the file.
3. Set the variable (export QASPIDER_KEY=qsp_YOUR_KEY) and restart Cursor.
4. To sign in instead of using a key, leave out the headers block and approve the browser sign-in when Cursor asks.

{
  "mcpServers": {
    "qaspider": {
      "url": "https://www.qaspider.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:QASPIDER_KEY}"
      }
    }
  }
}

{
  "mcpServers": {
    "qaspider": {
      "url": "https://www.qaspider.com/api/mcp"
    }
  }
}

If the sign-in does not start, use the key. Cursor’s documentation shows static OAuth credentials, not automatic sign-in.

Checked against the vendor’s documentation.

Google’s agent-first IDE. Remote servers use serverUrl, not url.

1. Open Settings, Customizations, then the MCP config (global file ~/.gemini/config/mcp_config.json; a project can use .agents/mcp_config.json).
2. Add the entry below. Use serverUrl: Antigravity does not accept url or httpUrl for remote servers.
3. To sign in instead of using a key, leave out headers, then press Authenticate next to QA Spider under Installed MCP Servers.

{
  "mcpServers": {
    "qaspider": {
      "serverUrl": "https://www.qaspider.com/api/mcp",
      "headers": {
        "Authorization": "Bearer qsp_YOUR_KEY"
      }
    }
  }
}

{
  "mcpServers": {
    "qaspider": {
      "serverUrl": "https://www.qaspider.com/api/mcp"
    }
  }
}

The file holds your key in plain text. Keep it out of any repository.

Checked against the vendor’s documentation.

Visual Studio Code with Copilot agent mode.

1. Run “MCP: Open User Configuration” from the Command Palette (or create .vscode/mcp.json in a project).
2. Add the entry below. The inputs block makes VS Code ask for your key once and store it, so it is never in the file.
3. To sign in instead, leave out headers and inputs; VS Code opens the browser on first use.

{
  "inputs": [
    {
      "type": "promptString",
      "id": "qaspider-key",
      "description": "QA Spider connection key",
      "password": true
    }
  ],
  "servers": {
    "qaspider": {
      "type": "http",
      "url": "https://www.qaspider.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${input:qaspider-key}"
      }
    }
  }
}

{
  "servers": {
    "qaspider": {
      "type": "http",
      "url": "https://www.qaspider.com/api/mcp"
    }
  }
}

The top-level key is servers (not mcpServers) in VS Code.

Checked against the vendor’s documentation.

The Cascade agent editor. Remote servers use serverUrl.

1. Open mcp_config.json from the MCP settings in Cascade (the vendor page lists where the file lives on each system).
2. Add the entry below and set QASPIDER_KEY in your environment. Windsurf reads ${env:NAME} inside headers.

{
  "mcpServers": {
    "qaspider": {
      "serverUrl": "https://www.qaspider.com/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:QASPIDER_KEY}"
      }
    }
  }
}

The vendor page says OAuth is supported for each transport but does not show the steps, so this page documents the key.

Checked against the vendor’s documentation.

The Zed editor lists remote servers under context_servers.

1. Run “zed: open settings file”, or use Settings, AI, MCP Servers.
2. Add the entry below. With no Authorization header, Zed starts the standard MCP sign-in for you.

{
  "context_servers": {
    "qaspider": {
      "url": "https://www.qaspider.com/api/mcp",
      "headers": {
        "Authorization": "Bearer qsp_YOUR_KEY"
      }
    }
  }
}

{
  "context_servers": {
    "qaspider": {
      "url": "https://www.qaspider.com/api/mcp"
    }
  }
}

The settings file holds your key in plain text. Zed settings are often synced or committed, so prefer the sign-in.

Checked against the vendor’s documentation.

The Cline extension for VS Code and JetBrains.

1. In Cline, open the MCP Servers icon, then Configure, then Configure MCP Servers.
2. Add the entry below. Set type to streamableHttp: leaving it out selects the older SSE transport.

{
  "mcpServers": {
    "qaspider": {
      "type": "streamableHttp",
      "url": "https://www.qaspider.com/api/mcp",
      "headers": {
        "Authorization": "Bearer qsp_YOUR_KEY"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

The file holds your key in plain text; keep autoApprove empty so Cline asks before each tool call.

Checked against the vendor’s documentation.

The Continue extension. MCP works in agent mode only.

1. Create .continue/mcpServers/qaspider.yaml in your project.
2. Paste the file below and store the key as a Continue secret named QASPIDER_KEY.
3. Switch Continue to agent mode: MCP tools are not available in chat mode.

name: QA Spider
version: 0.0.1
schema: v1
mcpServers:
  - name: QA Spider
    type: streamable-http
    url: https://www.qaspider.com/api/mcp
    requestOptions:
      headers:
        Authorization: "Bearer ${{ secrets.QASPIDER_KEY }}"

Checked against the vendor’s documentation.

IntelliJ IDEA, PyCharm, WebStorm and the other JetBrains IDEs.

1. Open Settings, Tools, AI Assistant, Model Context Protocol (MCP), press Add and paste the JSON below.
2. A remote server needs a recent AI Assistant release with Streamable HTTP support. If Add rejects the URL, update the IDE or use the mcp-remote bridge below.

{
  "mcpServers": {
    "qaspider": {
      "url": "https://www.qaspider.com/api/mcp",
      "headers": {
        "Authorization": "Bearer qsp_YOUR_KEY"
      }
    }
  }
}

JetBrains does not expand environment variables in this file, so the key is stored in the IDE settings.

Checked against the vendor’s documentation.

For clients that only start local (stdio) servers. The open-source mcp-remote package turns QA Spider into one.

1. You need Node.js. In your client’s MCP config add the entry below (the same mcpServers shape Claude Desktop, Cursor and Windsurf use for local servers).
2. With no header, mcp-remote opens the browser for the sign-in and keeps the tokens on your computer.
3. With a key, pass it in an environment variable. Write the header as Authorization:${QASPIDER_AUTH} with no space after the colon: some clients mangle spaces inside args, and a space inside the environment variable is fine.

{
  "mcpServers": {
    "qaspider": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://www.qaspider.com/api/mcp"
      ]
    }
  }
}

{
  "mcpServers": {
    "qaspider": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://www.qaspider.com/api/mcp",
        "--header",
        "Authorization:${QASPIDER_AUTH}"
      ],
      "env": {
        "QASPIDER_AUTH": "Bearer qsp_YOUR_KEY"
      }
    }
  }
}

mcp-remote is a separate open-source project, not made by QA Spider. Drop it as soon as your client supports remote servers directly.

Checked against the vendor’s documentation.