Serveur MCP QA Spider : corrigez votre site depuis Cursor, Claude et Codex

Les connecteurs personnalisés fonctionnent dans claude.ai, Claude Desktop et les applications mobiles, via votre compte Claude.

1. Offres individuelles : ouvrez Customize, puis Connectors, appuyez sur + Add et choisissez Add custom connector. Sur Team et Enterprise, un propriétaire l’ajoute dans Organization settings, Connectors, Add, Custom, Web.
2. Nommez-le QA Spider et collez l’adresse : https://www.qaspider.com/api/mcp
3. Appuyez sur Connect et connectez-vous avec votre compte QA Spider, puis choisissez l’équipe et les autorisations sur l’écran de consentement.
4. Vous préférez une clé ? Sous Request headers, ajoutez un en-tête fixe, Authorization, avec la valeur indiquée ci-dessous.

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

Authorization: Bearer qsp_YOUR_KEY

Claude se connecte depuis le cloud d’Anthropic, pas depuis votre ordinateur : le serveur doit donc être joignable depuis Internet. QA Spider l’est.

Les comptes Claude gratuits peuvent ajouter un connecteur personnalisé.

Le fichier claude_desktop_config.json est un mécanisme distinct pour les serveurs locaux ; utilisez l’écran des connecteurs pour un serveur distant.

Vérifié d’après la documentation de l’éditeur.

ChatGPT sur le web peut utiliser un serveur MCP distant comme application en mode développeur.

1. Dans ChatGPT sur le web, activez le mode Developer (Settings, Security and login), puis créez une application depuis l’écran des plugins avec le bouton +. OpenAI renomme souvent ces écrans ; la page de l’éditeur ci-dessous donne les noms actuels.
2. Choisissez un serveur MCP distant et collez l’adresse : https://www.qaspider.com/api/mcp
3. Choisissez OAuth comme authentification, puis connectez-vous avec votre compte QA Spider et choisissez l’équipe et les autorisations.
4. La nouvelle application apparaît sous Drafts, où vous pouvez activer ou désactiver chaque outil.

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

Disponible sur le web pour les comptes Pro, Plus, Business, Enterprise et Education.

La documentation d’OpenAI indique OAuth ou aucune authentification pour ces applications, pas de clé bearer ; utilisez donc la connexion ici.

ChatGPT vous demande de confirmer tout outil qui n’est pas marqué en lecture seule.

Vérifié d’après la documentation de l’éditeur.

L’agent de code d’Anthropic pour le terminal et l’IDE.

1. Exécutez la commande d’ajout ci-dessous dans votre terminal.
2. Lancez Claude Code et tapez /mcp. Choisissez qaspider et suivez la connexion dans le navigateur, puis choisissez l’équipe et les autorisations.
3. Vous préférez une clé ? Utilisez plutôt la deuxième commande, avec la clé de votre tableau de bord.

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

Ajoutez --scope user pour le rendre disponible dans chaque projet, ou --scope project pour écrire .mcp.json pour votre équipe. Par défaut, il est local au projet courant.

.mcp.json développe ${VAR} : committez donc le fichier et gardez la clé dans l’environnement de votre shell.

Vérifié d’après la documentation de l’éditeur.

Le CLI Codex, l’extension IDE et l’application de bureau ChatGPT partagent un même fichier de configuration.

1. Ouvrez ~/.codex/config.toml et ajoutez le bloc ci-dessous.
2. Avec une clé : export QASPIDER_KEY=qsp_YOUR_KEY dans le shell qui lance Codex. Codex l’envoie comme jeton bearer.
3. Avec connexion : gardez seulement la ligne url, puis exécutez la commande de connexion et approuvez la connexion dans le navigateur.

[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 utilise l’enregistrement dynamique de client quand le serveur le propose, ce que fait QA Spider.

Vérifié d’après la documentation de l’éditeur.

L’agent open source de Google pour le terminal. Les serveurs distants utilisent httpUrl.

1. Exécutez la commande ci-dessous, ou ajoutez l’entrée à ~/.gemini/settings.json (utilisateur) ou .gemini/settings.json (projet).
2. Utilisez une clé de connexion : la documentation de Gemini CLI montre headers pour cela, et OAuth seulement avec un client id que vous enregistrez vous-même.

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

Le fichier de paramètres contient votre clé en clair. Utilisez le fichier au niveau utilisateur, pas un fichier dans un dépôt.

Vérifié d’après la documentation de l’éditeur.

Les agents du terminal Warp peuvent utiliser des serveurs MCP par URL.

1. Ouvrez Settings, Agents, MCP servers (ou cherchez « Open MCP Servers » dans la palette de commandes) et appuyez sur + Add.
2. Choisissez un serveur Streamable HTTP ou SSE (URL) et collez le JSON ci-dessous.

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

La documentation de Warp décrit une connexion par navigateur pour les serveurs avec OAuth intégré ; utilisez la clé si elle ne démarre pas.

Vérifié d’après la documentation de l’éditeur.

L’éditeur de code avec IA. Un seul fichier contient tous les serveurs MCP.

1. Ouvrez ~/.cursor/mcp.json pour utiliser QA Spider dans tous les projets, ou .cursor/mcp.json dans un seul projet.
2. Ajoutez l’entrée ci-dessous. Cursor lit ${env:NAME} dans votre environnement : la clé n’est donc jamais dans le fichier.
3. Définissez la variable (export QASPIDER_KEY=qsp_YOUR_KEY) et redémarrez Cursor.
4. Pour vous connecter au lieu d’utiliser une clé, omettez le bloc headers et approuvez la connexion dans le navigateur quand Cursor la demande.

{
  "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 la connexion ne démarre pas, utilisez la clé. La documentation de Cursor montre des identifiants OAuth statiques, pas une connexion automatique.

Vérifié d’après la documentation de l’éditeur.

L’IDE de Google centré sur les agents. Les serveurs distants utilisent serverUrl, pas url.

1. Ouvrez Settings, Customizations, puis la configuration MCP (fichier global ~/.gemini/config/mcp_config.json ; un projet peut utiliser .agents/mcp_config.json).
2. Ajoutez l’entrée ci-dessous. Utilisez serverUrl : Antigravity n’accepte ni url ni httpUrl pour les serveurs distants.
3. Pour vous connecter au lieu d’utiliser une clé, omettez headers, puis appuyez sur Authenticate à côté de QA Spider sous 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"
    }
  }
}

Le fichier contient votre clé en clair. Gardez-le hors de tout dépôt.

Vérifié d’après la documentation de l’éditeur.

Visual Studio Code avec le mode agent de Copilot.

1. Exécutez « MCP: Open User Configuration » depuis la palette de commandes (ou créez .vscode/mcp.json dans un projet).
2. Ajoutez l’entrée ci-dessous. Le bloc inputs fait que VS Code demande votre clé une fois et la stocke : elle n’est donc jamais dans le fichier.
3. Pour vous connecter à la place, omettez headers et inputs ; VS Code ouvre le navigateur à la première utilisation.

{
  "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 clé de premier niveau est servers (et non mcpServers) dans VS Code.

Vérifié d’après la documentation de l’éditeur.

L’éditeur à agent Cascade. Les serveurs distants utilisent serverUrl.

1. Ouvrez mcp_config.json depuis les paramètres MCP de Cascade (la page de l’éditeur indique où se trouve le fichier sur chaque système).
2. Ajoutez l’entrée ci-dessous et définissez QASPIDER_KEY dans votre environnement. Windsurf lit ${env:NAME} dans headers.

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

La page de l’éditeur dit qu’OAuth est pris en charge pour chaque transport mais n’en montre pas les étapes ; cette page documente donc la clé.

Vérifié d’après la documentation de l’éditeur.

L’éditeur Zed liste les serveurs distants sous context_servers.

1. Exécutez « zed: open settings file », ou utilisez Settings, AI, MCP Servers.
2. Ajoutez l’entrée ci-dessous. Sans en-tête Authorization, Zed lance pour vous la connexion MCP standard.

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

Le fichier de paramètres contient votre clé en clair. Les paramètres de Zed sont souvent synchronisés ou committés : préférez la connexion.

Vérifié d’après la documentation de l’éditeur.

L’extension Cline pour VS Code et JetBrains.

1. Dans Cline, ouvrez l’icône MCP Servers, puis Configure, puis Configure MCP Servers.
2. Ajoutez l’entrée ci-dessous. Définissez type sur streamableHttp : l’omettre sélectionne l’ancien transport SSE.

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

Le fichier contient votre clé en clair ; laissez autoApprove vide pour que Cline demande avant chaque appel d’outil.

Vérifié d’après la documentation de l’éditeur.

L’extension Continue. MCP ne fonctionne qu’en mode agent.

1. Créez .continue/mcpServers/qaspider.yaml dans votre projet.
2. Collez le fichier ci-dessous et stockez la clé comme secret Continue nommé QASPIDER_KEY.
3. Passez Continue en mode agent : les outils MCP ne sont pas disponibles en mode 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 }}"

Vérifié d’après la documentation de l’éditeur.

IntelliJ IDEA, PyCharm, WebStorm et les autres IDE JetBrains.

1. Ouvrez Settings, Tools, AI Assistant, Model Context Protocol (MCP), appuyez sur Add et collez le JSON ci-dessous.
2. Un serveur distant nécessite une version récente d’AI Assistant avec prise en charge de Streamable HTTP. Si Add rejette l’URL, mettez l’IDE à jour ou utilisez le pont mcp-remote ci-dessous.

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

JetBrains ne développe pas les variables d’environnement dans ce fichier : la clé est donc stockée dans les paramètres de l’IDE.

Vérifié d’après la documentation de l’éditeur.

Pour les clients qui ne lancent que des serveurs locaux (stdio). Le paquet open source mcp-remote transforme QA Spider en un tel serveur.

1. Il vous faut Node.js. Dans la configuration MCP de votre client, ajoutez l’entrée ci-dessous (la même forme mcpServers que celle utilisée par Claude Desktop, Cursor et Windsurf pour les serveurs locaux).
2. Sans en-tête, mcp-remote ouvre le navigateur pour la connexion et garde les jetons sur votre ordinateur.
3. Avec une clé, passez-la dans une variable d’environnement. Écrivez l’en-tête comme Authorization:${QASPIDER_AUTH} sans espace après les deux-points : certains clients abîment les espaces dans args, alors qu’un espace dans la variable d’environnement ne pose pas de problème.

{
  "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 est un projet open source distinct, qui n’est pas fait par QA Spider. Abandonnez-le dès que votre client prend en charge directement les serveurs distants.

Vérifié d’après la documentation de l’éditeur.