Servidor MCP do QA Spider: corrija seu site a partir do Cursor, Claude e Codex

Conectores personalizados funcionam no claude.ai, no Claude Desktop e nos apps para celular, pela sua conta do Claude.

1. Planos individuais: abra Customize, depois Connectors, clique em + Add e escolha Add custom connector. Em Team e Enterprise, um proprietário o adiciona em Organization settings, Connectors, Add, Custom, Web.
2. Dê o nome QA Spider e cole o endereço: https://www.qaspider.com/api/mcp
3. Clique em Connect e entre com sua conta do QA Spider; depois escolha a equipe e as permissões na tela de consentimento.
4. Prefere uma chave? Em Request headers, adicione um cabeçalho fixo, Authorization, com o valor mostrado abaixo.

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

Authorization: Bearer qsp_YOUR_KEY

O Claude se conecta a partir da nuvem da Anthropic, não do seu computador, então o servidor precisa ser acessível pela internet. O QA Spider é.

Contas gratuitas do Claude podem adicionar um conector personalizado.

O arquivo claude_desktop_config.json é um mecanismo separado para servidores locais; use a tela de conectores para um servidor remoto.

Conferido com a documentação do fornecedor.

O ChatGPT na web pode usar um servidor MCP remoto como um app do modo desenvolvedor.

1. No ChatGPT na web, ative o Developer mode (Settings, Security and login) e depois crie um app na tela de plugins com o botão +. A OpenAI renomeia essas telas com frequência; a página do fornecedor abaixo tem os nomes atuais.
2. Escolha um servidor MCP remoto e cole o endereço: https://www.qaspider.com/api/mcp
3. Escolha OAuth como autenticação, depois entre com sua conta do QA Spider e selecione a equipe e as permissões.
4. O novo app aparece em Drafts, onde você pode ativar ou desativar ferramentas individuais.

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

Disponível na web para contas Pro, Plus, Business, Enterprise e Education.

A documentação da OpenAI lista OAuth ou nenhuma autenticação para esses apps, não uma chave bearer; por isso, use o login aqui.

O ChatGPT pede que você confirme qualquer ferramenta que não esteja marcada como somente leitura.

Conferido com a documentação do fornecedor.

O agente de programação da Anthropic para o terminal e a IDE.

1. Execute o comando de adição abaixo no seu terminal.
2. Inicie o Claude Code e digite /mcp. Escolha qaspider e siga o login no navegador; depois selecione a equipe e as permissões.
3. Prefere uma chave? Use o segundo comando, com a chave do seu painel.

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}"
      }
    }
  }
}

Adicione --scope user para disponibilizá-lo em todos os projetos, ou --scope project para gravar o .mcp.json para sua equipe. O padrão é local ao projeto atual.

O .mcp.json expande ${VAR}, então faça commit do arquivo e mantenha a chave no ambiente do seu shell.

Conferido com a documentação do fornecedor.

A CLI do Codex, a extensão de IDE e o app desktop do ChatGPT compartilham um único arquivo de configuração.

1. Abra ~/.codex/config.toml e adicione o bloco abaixo.
2. Com uma chave: export QASPIDER_KEY=qsp_YOUR_KEY no shell que inicia o Codex. O Codex a envia como token bearer.
3. Com login: mantenha apenas a linha url, execute o comando de login e aprove o login no navegador.

[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

O Codex usa o registro dinâmico de clientes quando o servidor o oferece, o que o QA Spider faz.

Conferido com a documentação do fornecedor.

O agente de terminal de código aberto do Google. Servidores remotos usam httpUrl.

1. Execute o comando abaixo ou adicione a entrada a ~/.gemini/settings.json (usuário) ou .gemini/settings.json (projeto).
2. Use uma chave de conexão: a documentação do Gemini CLI mostra headers para isso, e OAuth apenas com um client id que você mesmo registra.

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"
      }
    }
  }
}

O arquivo de configurações guarda sua chave em texto simples. Use o arquivo no nível do usuário, não um dentro de um repositório.

Conferido com a documentação do fornecedor.

Os agentes do terminal Warp podem usar servidores MCP baseados em URL.

1. Abra Settings, Agents, MCP servers (ou procure “Open MCP Servers” na Command Palette) e clique em + Add.
2. Escolha um servidor Streamable HTTP ou SSE (URL) e cole o JSON abaixo.

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

A documentação do Warp descreve o login no navegador para servidores com OAuth integrado; use a chave se ele não iniciar.

Conferido com a documentação do fornecedor.

O editor de código com AI. Um único arquivo guarda todos os servidores MCP.

1. Abra ~/.cursor/mcp.json para usar o QA Spider em todos os projetos, ou .cursor/mcp.json dentro de um projeto.
2. Adicione a entrada abaixo. O Cursor lê ${env:NAME} do seu ambiente, então a chave nunca vai para o arquivo.
3. Defina a variável (export QASPIDER_KEY=qsp_YOUR_KEY) e reinicie o Cursor.
4. Para entrar em vez de usar uma chave, omita o bloco headers e aprove o login no navegador quando o Cursor pedir.

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

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

Se o login não iniciar, use a chave. A documentação do Cursor mostra credenciais OAuth estáticas, não login automático.

Conferido com a documentação do fornecedor.

A IDE do Google voltada a agentes. Servidores remotos usam serverUrl, não url.

1. Abra Settings, Customizations e depois a configuração de MCP (arquivo global ~/.gemini/config/mcp_config.json; um projeto pode usar .agents/mcp_config.json).
2. Adicione a entrada abaixo. Use serverUrl: o Antigravity não aceita url nem httpUrl para servidores remotos.
3. Para entrar em vez de usar uma chave, omita headers e clique em Authenticate ao lado do QA Spider em 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"
    }
  }
}

O arquivo guarda sua chave em texto simples. Mantenha-o fora de qualquer repositório.

Conferido com a documentação do fornecedor.

Visual Studio Code com o modo agente do Copilot.

1. Execute “MCP: Open User Configuration” na Command Palette (ou crie .vscode/mcp.json em um projeto).
2. Adicione a entrada abaixo. O bloco inputs faz o VS Code pedir sua chave uma vez e armazená-la, de modo que ela nunca fique no arquivo.
3. Para entrar em vez disso, omita headers e inputs; o VS Code abre o navegador no primeiro uso.

{
  "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"
    }
  }
}

No VS Code, a chave de nível superior é servers (não mcpServers).

Conferido com a documentação do fornecedor.

O editor com o agente Cascade. Servidores remotos usam serverUrl.

1. Abra o mcp_config.json nas configurações de MCP do Cascade (a página do fornecedor lista onde o arquivo fica em cada sistema).
2. Adicione a entrada abaixo e defina QASPIDER_KEY no seu ambiente. O Windsurf lê ${env:NAME} dentro de headers.

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

A página do fornecedor diz que OAuth é suportado em cada transporte, mas não mostra os passos; por isso, esta página documenta a chave.

Conferido com a documentação do fornecedor.

O editor Zed lista servidores remotos em context_servers.

1. Execute “zed: open settings file” ou use Settings, AI, MCP Servers.
2. Adicione a entrada abaixo. Sem o cabeçalho Authorization, o Zed inicia para você o login padrão do MCP.

{
  "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"
    }
  }
}

O arquivo de configurações guarda sua chave em texto simples. As configurações do Zed costumam ser sincronizadas ou versionadas, então prefira o login.

Conferido com a documentação do fornecedor.

A extensão Cline para VS Code e JetBrains.

1. No Cline, abra o ícone MCP Servers, depois Configure e então Configure MCP Servers.
2. Adicione a entrada abaixo. Defina type como streamableHttp: se omitir, o transporte SSE mais antigo é selecionado.

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

O arquivo guarda sua chave em texto simples; mantenha autoApprove vazio para que o Cline pergunte antes de cada chamada de ferramenta.

Conferido com a documentação do fornecedor.

A extensão Continue. O MCP funciona apenas no modo agente.

1. Crie .continue/mcpServers/qaspider.yaml no seu projeto.
2. Cole o arquivo abaixo e armazene a chave como um segredo do Continue chamado QASPIDER_KEY.
3. Mude o Continue para o modo agente: as ferramentas MCP não estão disponíveis no modo chat.

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 }}"

Conferido com a documentação do fornecedor.

IntelliJ IDEA, PyCharm, WebStorm e as outras IDEs da JetBrains.

1. Abra Settings, Tools, AI Assistant, Model Context Protocol (MCP), clique em Add e cole o JSON abaixo.
2. Um servidor remoto exige uma versão recente do AI Assistant com suporte a Streamable HTTP. Se o Add rejeitar a URL, atualize a IDE ou use a ponte mcp-remote abaixo.

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

A JetBrains não expande variáveis de ambiente neste arquivo, então a chave fica armazenada nas configurações da IDE.

Conferido com a documentação do fornecedor.

Para clientes que só iniciam servidores locais (stdio). O pacote de código aberto mcp-remote transforma o QA Spider em um deles.

1. Você precisa do Node.js. Na configuração de MCP do seu cliente, adicione a entrada abaixo (o mesmo formato mcpServers que Claude Desktop, Cursor e Windsurf usam para servidores locais).
2. Sem cabeçalho, o mcp-remote abre o navegador para o login e mantém os tokens no seu computador.
3. Com uma chave, passe-a em uma variável de ambiente. Escreva o cabeçalho como Authorization:${QASPIDER_AUTH} sem espaço depois dos dois-pontos: alguns clientes estragam espaços dentro de args, e um espaço dentro da variável de ambiente não causa problema.

{
  "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"
      }
    }
  }
}

O mcp-remote é um projeto de código aberto separado, não feito pelo QA Spider. Abandone-o assim que o seu cliente suportar servidores remotos diretamente.

Conferido com a documentação do fornecedor.