Servidor MCP de QA Spider: arregla tu sitio desde Cursor, Claude y Codex

Los conectores personalizados funcionan en claude.ai, Claude Desktop y las apps móviles a través de tu cuenta de Claude.

1. Planes individuales: abre Customize, luego Connectors, pulsa + Add y elige Add custom connector. En Team y Enterprise, un propietario lo añade en Organization settings, Connectors, Add, Custom, Web.
2. Ponle el nombre QA Spider y pega la dirección: https://www.qaspider.com/api/mcp
3. Pulsa Connect e inicia sesión con tu cuenta de QA Spider; luego elige el equipo y los permisos en la pantalla de consentimiento.
4. ¿Prefieres una clave? En Request headers añade una única cabecera fija, Authorization con el valor que se muestra abajo.

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

Authorization: Bearer qsp_YOUR_KEY

Claude se conecta desde la nube de Anthropic, no desde tu ordenador, así que el servidor debe ser accesible desde internet. QA Spider lo es.

Las cuentas gratuitas de Claude pueden añadir un conector personalizado.

El archivo claude_desktop_config.json es un mecanismo aparte para servidores locales; usa la pantalla de conectores para uno remoto.

Comprobado con la documentación del proveedor.

ChatGPT en la web puede usar un servidor MCP remoto como app en modo desarrollador.

1. En ChatGPT en la web, activa el modo desarrollador (Settings, Security and login) y luego crea una app desde la pantalla de plugins con el botón +. OpenAI cambia a menudo el nombre de estas pantallas; la página del proveedor de abajo tiene los nombres actuales.
2. Elige un servidor MCP remoto y pega la dirección: https://www.qaspider.com/api/mcp
3. Elige OAuth como autenticación; luego inicia sesión con tu cuenta de QA Spider y elige el equipo y los permisos.
4. La nueva app aparece en Drafts, donde puedes activar o desactivar herramientas individuales.

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

Disponible en la web para cuentas Pro, Plus, Business, Enterprise y Education.

La documentación de OpenAI indica OAuth o ninguna autenticación para estas apps, no una clave bearer, así que usa aquí el inicio de sesión.

ChatGPT te pide confirmar cualquier herramienta que no esté marcada como de solo lectura.

Comprobado con la documentación del proveedor.

El agente de programación de Anthropic para la terminal y el IDE.

1. Ejecuta en tu terminal el comando de añadir de abajo.
2. Inicia Claude Code y escribe /mcp. Elige qaspider y sigue el inicio de sesión en el navegador; luego elige el equipo y los permisos.
3. ¿Prefieres una clave? Usa el segundo comando, con la clave de tu panel.

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

Añade --scope user para que esté disponible en todos los proyectos, o --scope project para escribir .mcp.json para tu equipo. Por defecto es local al proyecto actual.

.mcp.json expande ${VAR}, así que puedes subir el archivo al repositorio y mantener la clave en el entorno de tu shell.

Comprobado con la documentación del proveedor.

La CLI de Codex, la extensión de IDE y la app de escritorio de ChatGPT comparten un archivo de configuración.

1. Abre ~/.codex/config.toml y añade el bloque de abajo.
2. Con una clave: export QASPIDER_KEY=qsp_YOUR_KEY en la shell que inicia Codex. Codex la envía como token bearer.
3. Con inicio de sesión: deja solo la línea url, ejecuta el comando de inicio de sesión y aprueba el inicio de sesión en el 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

Codex usa el registro dinámico de clientes cuando el servidor lo ofrece, y QA Spider lo ofrece.

Comprobado con la documentación del proveedor.

El agente de terminal de código abierto de Google. Los servidores remotos usan httpUrl.

1. Ejecuta el comando de abajo, o añade la entrada a ~/.gemini/settings.json (usuario) o .gemini/settings.json (proyecto).
2. Usa una clave de conexión: la documentación de Gemini CLI muestra headers para esto, y OAuth solo con un client id que registres tú mismo.

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

El archivo de ajustes guarda tu clave en texto plano. Usa el archivo a nivel de usuario, no uno dentro de un repositorio.

Comprobado con la documentación del proveedor.

Los agentes de la terminal Warp pueden usar servidores MCP basados en URL.

1. Abre Settings, Agents, MCP servers (o busca “Open MCP Servers” en la Paleta de comandos) y pulsa + Add.
2. Elige un servidor Streamable HTTP o SSE (URL) y pega el JSON de abajo.

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

La documentación de Warp describe el inicio de sesión en el navegador para servidores con OAuth integrado; usa la clave si no arranca.

Comprobado con la documentación del proveedor.

El editor de código con AI. Un solo archivo contiene todos los servidores MCP.

1. Abre ~/.cursor/mcp.json para usar QA Spider en todos los proyectos, o .cursor/mcp.json dentro de un proyecto.
2. Añade la entrada de abajo. Cursor lee ${env:NAME} de tu entorno, así que la clave nunca va en el archivo.
3. Define la variable (export QASPIDER_KEY=qsp_YOUR_KEY) y reinicia Cursor.
4. Para iniciar sesión en lugar de usar una clave, omite el bloque headers y aprueba el inicio de sesión en el navegador cuando Cursor lo pida.

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

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

Si el inicio de sesión no arranca, usa la clave. La documentación de Cursor muestra credenciales OAuth estáticas, no inicio de sesión automático.

Comprobado con la documentación del proveedor.

El IDE de Google centrado en agentes. Los servidores remotos usan serverUrl, no url.

1. Abre Settings, Customizations y luego la configuración de MCP (archivo global ~/.gemini/config/mcp_config.json; un proyecto puede usar .agents/mcp_config.json).
2. Añade la entrada de abajo. Usa serverUrl: Antigravity no acepta url ni httpUrl para servidores remotos.
3. Para iniciar sesión en lugar de usar una clave, omite headers y pulsa Authenticate junto a QA Spider en 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"
    }
  }
}

El archivo guarda tu clave en texto plano. Mantenlo fuera de cualquier repositorio.

Comprobado con la documentación del proveedor.

Visual Studio Code con el modo agente de Copilot.

1. Ejecuta “MCP: Open User Configuration” desde la Paleta de comandos (o crea .vscode/mcp.json en un proyecto).
2. Añade la entrada de abajo. El bloque inputs hace que VS Code te pida la clave una vez y la guarde, así que nunca está en el archivo.
3. Para iniciar sesión en su lugar, omite headers e inputs; VS Code abre el navegador en el primer 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"
    }
  }
}

La clave de nivel superior es servers (no mcpServers) en VS Code.

Comprobado con la documentación del proveedor.

El editor con el agente Cascade. Los servidores remotos usan serverUrl.

1. Abre mcp_config.json desde los ajustes de MCP en Cascade (la página del proveedor indica dónde está el archivo en cada sistema).
2. Añade la entrada de abajo y define QASPIDER_KEY en tu entorno. Windsurf lee ${env:NAME} dentro de headers.

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

La página del proveedor dice que OAuth se admite en cada transporte pero no muestra los pasos, así que esta página documenta la clave.

Comprobado con la documentación del proveedor.

El editor Zed lista los servidores remotos en context_servers.

1. Ejecuta “zed: open settings file”, o usa Settings, AI, MCP Servers.
2. Añade la entrada de abajo. Sin cabecera Authorization, Zed inicia por ti el inicio de sesión estándar de 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"
    }
  }
}

El archivo de ajustes guarda tu clave en texto plano. Los ajustes de Zed a menudo se sincronizan o se suben al repositorio, así que es mejor el inicio de sesión.

Comprobado con la documentación del proveedor.

La extensión Cline para VS Code y JetBrains.

1. En Cline, abre el icono MCP Servers, luego Configure y después Configure MCP Servers.
2. Añade la entrada de abajo. Define type como streamableHttp: si lo omites, se elige el transporte SSE más antiguo.

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

El archivo guarda tu clave en texto plano; deja autoApprove vacío para que Cline pregunte antes de cada llamada a una herramienta.

Comprobado con la documentación del proveedor.

La extensión Continue. MCP funciona solo en modo agente.

1. Crea .continue/mcpServers/qaspider.yaml en tu proyecto.
2. Pega el archivo de abajo y guarda la clave como un secreto de Continue llamado QASPIDER_KEY.
3. Cambia Continue al modo agente: las herramientas MCP no están disponibles en el 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 }}"

Comprobado con la documentación del proveedor.

IntelliJ IDEA, PyCharm, WebStorm y los demás IDEs de JetBrains.

1. Abre Settings, Tools, AI Assistant, Model Context Protocol (MCP), pulsa Add y pega el JSON de abajo.
2. Un servidor remoto necesita una versión reciente de AI Assistant con soporte de Streamable HTTP. Si Add rechaza la URL, actualiza el IDE o usa el puente mcp-remote de abajo.

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

JetBrains no expande variables de entorno en este archivo, así que la clave se guarda en los ajustes del IDE.

Comprobado con la documentación del proveedor.

Para clientes que solo inician servidores locales (stdio). El paquete de código abierto mcp-remote convierte QA Spider en uno.

1. Necesitas Node.js. En la configuración MCP de tu cliente añade la entrada de abajo (la misma forma mcpServers que usan Claude Desktop, Cursor y Windsurf para servidores locales).
2. Sin cabecera, mcp-remote abre el navegador para el inicio de sesión y guarda los tokens en tu ordenador.
3. Con una clave, pásala en una variable de entorno. Escribe la cabecera como Authorization:${QASPIDER_AUTH} sin espacio tras los dos puntos: algunos clientes alteran los espacios dentro de args, y un espacio dentro de la variable de entorno no da problemas.

{
  "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 es un proyecto de código abierto independiente, no hecho por QA Spider. Déjalo en cuanto tu cliente admita servidores remotos directamente.

Comprobado con la documentación del proveedor.