Server MCP di QA Spider: correggi il tuo sito da Cursor, Claude e Codex

I connettori personalizzati funzionano in claude.ai, in Claude Desktop e nelle app mobile tramite il tuo account Claude.

1. Piani individuali: apri Customize, poi Connectors, premi + Add e scegli Add custom connector. Nei piani Team ed Enterprise, un proprietario lo aggiunge in Organization settings, Connectors, Add, Custom, Web.
2. Chiamalo QA Spider e incolla l'indirizzo: https://www.qaspider.com/api/mcp
3. Premi Connect e accedi con il tuo account QA Spider, poi scegli il team e i permessi nella schermata di consenso.
4. Preferisci una chiave? In Request headers aggiungi un header fisso, Authorization, con il valore mostrato qui sotto.

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

Authorization: Bearer qsp_YOUR_KEY

Claude si connette dal cloud di Anthropic, non dal tuo computer, quindi il server deve essere raggiungibile da internet. QA Spider lo è.

Gli account Claude gratuiti possono aggiungere un solo connettore personalizzato.

Il file claude_desktop_config.json è un meccanismo separato per i server locali; per uno remoto usa la schermata dei connettori.

Verificato rispetto alla documentazione del fornitore.

ChatGPT sul web può usare un server MCP remoto come app in modalità sviluppatore.

1. In ChatGPT sul web, attiva Developer mode (Settings, Security and login), poi crea un'app dalla schermata dei plugin con il pulsante +. OpenAI rinomina spesso queste schermate; la pagina del fornitore qui sotto riporta i nomi attuali.
2. Scegli un server MCP remoto e incolla l'indirizzo: https://www.qaspider.com/api/mcp
3. Scegli OAuth come autenticazione, poi accedi con il tuo account QA Spider e seleziona il team e i permessi.
4. La nuova app compare in Drafts, dove puoi attivare o disattivare i singoli strumenti.

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

Disponibile sul web per gli account Pro, Plus, Business, Enterprise ed Education.

La documentazione di OpenAI per queste app elenca OAuth o nessuna autenticazione, non una chiave bearer, quindi usa qui l'accesso.

ChatGPT ti chiede di confermare ogni strumento non contrassegnato come di sola lettura.

Verificato rispetto alla documentazione del fornitore.

L'agente di coding di Anthropic per il terminale e l'IDE.

1. Esegui nel terminale il comando di aggiunta qui sotto.
2. Avvia Claude Code e digita /mcp. Scegli qaspider e segui l'accesso nel browser, poi seleziona il team e i permessi.
3. Preferisci una chiave? Usa invece il secondo comando, con la chiave della tua 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}"
      }
    }
  }
}

Aggiungi --scope user per renderlo disponibile in ogni progetto, oppure --scope project per scrivere .mcp.json per il tuo team. Il comportamento predefinito è locale al progetto corrente.

.mcp.json espande ${VAR}, quindi puoi committare il file e tenere la chiave nell'ambiente della tua shell.

Verificato rispetto alla documentazione del fornitore.

La CLI di Codex, l'estensione per IDE e l'app desktop di ChatGPT condividono un unico file di configurazione.

1. Apri ~/.codex/config.toml e aggiungi il blocco qui sotto.
2. Con una chiave: export QASPIDER_KEY=qsp_YOUR_KEY nella shell che avvia Codex. Codex la invia come token bearer.
3. Con l'accesso: tieni solo la riga url, poi esegui il comando di login e approva l'accesso nel browser.

[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 la registrazione dinamica del client quando il server la offre, come fa QA Spider.

Verificato rispetto alla documentazione del fornitore.

L'agente da terminale open source di Google. I server remoti usano httpUrl.

1. Esegui il comando qui sotto, oppure aggiungi la voce a ~/.gemini/settings.json (utente) o .gemini/settings.json (progetto).
2. Usa una chiave di connessione: la documentazione di Gemini CLI mostra gli headers per questo, e OAuth solo con un client id che registri tu.

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

Il file delle impostazioni contiene la tua chiave in chiaro. Usa il file a livello utente, non uno dentro un repository.

Verificato rispetto alla documentazione del fornitore.

Gli agenti del terminale Warp possono usare server MCP basati su URL.

1. Apri Settings, Agents, MCP servers (oppure cerca «Open MCP Servers» nella Command Palette) e premi + Add.
2. Scegli un server Streamable HTTP o SSE (URL) e incolla il JSON qui sotto.

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

La documentazione di Warp descrive l'accesso nel browser per i server con OAuth integrato; usa la chiave se non parte.

Verificato rispetto alla documentazione del fornitore.

L'editor di codice con AI. Un solo file contiene tutti i server MCP.

1. Apri ~/.cursor/mcp.json per usare QA Spider in ogni progetto, oppure .cursor/mcp.json all'interno di un progetto.
2. Aggiungi la voce qui sotto. Cursor legge ${env:NAME} dal tuo ambiente, quindi la chiave non finisce mai nel file.
3. Imposta la variabile (export QASPIDER_KEY=qsp_YOUR_KEY) e riavvia Cursor.
4. Per accedere invece di usare una chiave, ometti il blocco headers e approva l'accesso nel browser quando Cursor lo chiede.

{
  "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 l'accesso non parte, usa la chiave. La documentazione di Cursor mostra credenziali OAuth statiche, non l'accesso automatico.

Verificato rispetto alla documentazione del fornitore.

L'IDE di Google pensato per gli agenti. I server remoti usano serverUrl, non url.

1. Apri Settings, Customizations, poi la configurazione MCP (file globale ~/.gemini/config/mcp_config.json; un progetto può usare .agents/mcp_config.json).
2. Aggiungi la voce qui sotto. Usa serverUrl: Antigravity non accetta url né httpUrl per i server remoti.
3. Per accedere invece di usare una chiave, ometti headers, poi premi Authenticate accanto a QA Spider in 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"
    }
  }
}

Il file contiene la tua chiave in chiaro. Tienilo fuori da qualsiasi repository.

Verificato rispetto alla documentazione del fornitore.

Visual Studio Code con la modalità agente di Copilot.

1. Esegui «MCP: Open User Configuration» dalla Command Palette (oppure crea .vscode/mcp.json in un progetto).
2. Aggiungi la voce qui sotto. Il blocco inputs fa sì che VS Code ti chieda la chiave una volta e la memorizzi, così non è mai nel file.
3. Per accedere invece, ometti headers e inputs; VS Code apre il browser al primo utilizzo.

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

In VS Code la chiave di primo livello è servers (non mcpServers).

Verificato rispetto alla documentazione del fornitore.

L'editor con l'agente Cascade. I server remoti usano serverUrl.

1. Apri mcp_config.json dalle impostazioni MCP di Cascade (la pagina del fornitore indica dove si trova il file su ogni sistema).
2. Aggiungi la voce qui sotto e imposta QASPIDER_KEY nel tuo ambiente. Windsurf legge ${env:NAME} dentro headers.

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

La pagina del fornitore dice che OAuth è supportato per ogni trasporto ma non mostra i passaggi, quindi questa pagina documenta la chiave.

Verificato rispetto alla documentazione del fornitore.

L'editor Zed elenca i server remoti in context_servers.

1. Esegui «zed: open settings file», oppure usa Settings, AI, MCP Servers.
2. Aggiungi la voce qui sotto. Senza l'header Authorization, Zed avvia per te l'accesso 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"
    }
  }
}

Il file delle impostazioni contiene la tua chiave in chiaro. Le impostazioni di Zed spesso vengono sincronizzate o committate, quindi preferisci l'accesso.

Verificato rispetto alla documentazione del fornitore.

L'estensione Cline per VS Code e JetBrains.

1. In Cline, apri l'icona MCP Servers, poi Configure, poi Configure MCP Servers.
2. Aggiungi la voce qui sotto. Imposta type su streamableHttp: omettendolo si seleziona il vecchio trasporto SSE.

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

Il file contiene la tua chiave in chiaro; lascia autoApprove vuoto così Cline chiede conferma prima di ogni chiamata a uno strumento.

Verificato rispetto alla documentazione del fornitore.

L'estensione Continue. MCP funziona solo in modalità agente.

1. Crea .continue/mcpServers/qaspider.yaml nel tuo progetto.
2. Incolla il file qui sotto e memorizza la chiave come segreto di Continue chiamato QASPIDER_KEY.
3. Passa Continue alla modalità agente: gli strumenti MCP non sono disponibili nella modalità 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 }}"

Verificato rispetto alla documentazione del fornitore.

IntelliJ IDEA, PyCharm, WebStorm e gli altri IDE JetBrains.

1. Apri Settings, Tools, AI Assistant, Model Context Protocol (MCP), premi Add e incolla il JSON qui sotto.
2. Un server remoto richiede una versione recente di AI Assistant con supporto Streamable HTTP. Se Add rifiuta l'URL, aggiorna l'IDE o usa il bridge mcp-remote qui sotto.

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

JetBrains non espande le variabili d'ambiente in questo file, quindi la chiave viene memorizzata nelle impostazioni dell'IDE.

Verificato rispetto alla documentazione del fornitore.

Per i client che avviano solo server locali (stdio). Il pacchetto open source mcp-remote trasforma QA Spider in uno di essi.

1. Ti serve Node.js. Nella configurazione MCP del tuo client aggiungi la voce qui sotto (la stessa struttura mcpServers che Claude Desktop, Cursor e Windsurf usano per i server locali).
2. Senza header, mcp-remote apre il browser per l'accesso e conserva i token sul tuo computer.
3. Con una chiave, passala in una variabile d'ambiente. Scrivi l'header come Authorization:${QASPIDER_AUTH} senza spazio dopo i due punti: alcuni client alterano gli spazi dentro args, mentre uno spazio dentro la variabile d'ambiente va bene.

{
  "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 è un progetto open source separato, non creato da QA Spider. Abbandonalo appena il tuo client supporta direttamente i server remoti.

Verificato rispetto alla documentazione del fornitore.