---
title: "Agents de code et éditeurs"
description: "Connectez Claude Code, Codex, Cursor, VS Code, OpenCode et Windsurf au serveur MCP de TwexAPI par connexion ou avec une clé API."
---

Tous les clients ci-dessous se connectent au même serveur, `https://api.twexapi.io/mcp`, en Streamable HTTP. La plupart peuvent se connecter avec votre compte TwexAPI : vous ajoutez seulement l'URL et le client ouvre un navigateur pour que vous approuviez l'accès. Utilisez une clé API si le client ne prend pas en charge la connexion MCP ou si vous préférez une clé.

| Client | Connexion avec TwexAPI | Clé API | Testé par TwexAPI |
| --- | --- | --- | --- |
| [Claude Code](#claude-code) | Oui | Oui | Non |
| [Cursor](#cursor) | Oui | Oui | Oui |
| [Codex](#codex) | Oui | Oui | Non |
| [VS Code](#vs-code) | Oui | Oui | Non |
| [OpenCode](#opencode) | Oui | Oui | Non |
| [Windsurf](#windsurf) | Non confirmé | Oui | Non |

« Testé » signifie que nous avons exécuté le flux complet, de la connexion à un appel d'outil, avec ce client. Les autres méthodes de connexion reposent sur la prise en charge de l'autorisation MCP documentée par chaque éditeur. Si la connexion échoue, utilisez une clé API. Pour Claude.ai, Claude Desktop et ChatGPT, consultez la [présentation du serveur MCP](/mcp/overview#claude-ai-and-claude-desktop) et [ChatGPT](/mcp/chatgpt).

:::tip
  Gardez les clés API dans des variables d'environnement, pas dans des fichiers de configuration que vous committez. Créez une clé dans le [tableau de bord TwexAPI](https://twexapi.io/dashboard).
:::

<a id="claude-code"></a>

## Claude Code

Ajoutez le serveur :

```bash
claude mcp add --transport http twexapi https://api.twexapi.io/mcp
```

Exécutez ensuite `/mcp` dans une session Claude Code, choisissez `twexapi` et sélectionnez **Authenticate** pour approuver l'accès dans le navigateur. Ajoutez `--scope project` pour partager le serveur avec votre équipe via `.mcp.json` ; chaque personne se connecte avec son propre compte.

Pour utiliser une clé API, placez l'en-tête dans `.mcp.json`. Claude Code développe `${TWEXAPI_API_KEY}` à partir de votre environnement :

```json
{
  "mcpServers": {
    "twexapi": {
      "type": "http",
      "url": "https://api.twexapi.io/mcp",
      "headers": {
        "x-api-key": "${TWEXAPI_API_KEY}"
      }
    }
  }
}
```

<a id="cursor"></a>

## Cursor

Ajoutez-le à `~/.cursor/mcp.json` (tous les projets) ou à `.cursor/mcp.json` (un projet) :

```json
{
  "mcpServers": {
    "twexapi": {
      "url": "https://api.twexapi.io/mcp"
    }
  }
}
```

Ouvrez **Settings → MCP**. Le serveur affiche **Needs authentication**. Sélectionnez **Authenticate**, approuvez l'accès dans le navigateur, puis autorisez le navigateur à ouvrir Cursor. Le serveur est prêt lorsqu'il affiche trois outils activés.

Pour utiliser une clé API :

```json
{
  "mcpServers": {
    "twexapi": {
      "url": "https://api.twexapi.io/mcp",
      "headers": {
        "x-api-key": "${env:TWEXAPI_API_KEY}"
      }
    }
  }
}
```

<a id="codex"></a>

## Codex

Ajoutez le serveur et connectez-vous :

```bash
codex mcp add twexapi --url https://api.twexapi.io/mcp
codex mcp login twexapi
codex mcp list
```

La CLI, l'application et l'extension IDE de Codex partagent la même configuration dans `~/.codex/config.toml` :

```toml
[mcp_servers.twexapi]
url = "https://api.twexapi.io/mcp"
```

Pour utiliser une clé API, indiquez la variable d'environnement qui la contient. Codex l'envoie en tant que `Authorization: Bearer` :

```toml
[mcp_servers.twexapi]
url = "https://api.twexapi.io/mcp"
bearer_token_env_var = "TWEXAPI_API_KEY"
```

<a id="vs-code"></a>

## VS Code

Exécutez **MCP: Add Server** depuis la palette de commandes et choisissez **HTTP**, ou ajoutez-le à `.vscode/mcp.json` :

```json
{
  "servers": {
    "twexapi": {
      "type": "http",
      "url": "https://api.twexapi.io/mcp"
    }
  }
}
```

Démarrez le serveur et approuvez la demande de connexion qui s'affiche dans le navigateur.

Pour utiliser une clé API, laissez VS Code vous la demander une fois et la stocker de manière sécurisée :

```json
{
  "inputs": [
    {
      "type": "promptString",
      "id": "twexapi-key",
      "description": "TwexAPI API key",
      "password": true
    }
  ],
  "servers": {
    "twexapi": {
      "type": "http",
      "url": "https://api.twexapi.io/mcp",
      "headers": {
        "x-api-key": "${input:twexapi-key}"
      }
    }
  }
}
```

<a id="opencode"></a>

## OpenCode

Ajoutez-le à `opencode.json` :

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "twexapi": {
      "type": "remote",
      "url": "https://api.twexapi.io/mcp"
    }
  }
}
```

OpenCode détecte que le serveur exige une connexion et ouvre le navigateur. Si ce n'est pas le cas, exécutez `opencode mcp auth twexapi`. Vérifiez l'état avec `opencode mcp list` et utilisez `opencode mcp debug twexapi` si la connexion échoue.

Pour utiliser une clé API, désactivez la connexion automatique :

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "twexapi": {
      "type": "remote",
      "url": "https://api.twexapi.io/mcp",
      "oauth": false,
      "headers": {
        "Authorization": "Bearer {env:TWEXAPI_API_KEY}"
      }
    }
  }
}
```

<a id="windsurf"></a>

## Windsurf

Nous n'avons pas encore confirmé la connexion dans Windsurf : utilisez donc une clé API. Ajoutez-la à `~/.codeium/windsurf/mcp_config.json` (ouvrez ce fichier depuis le menu MCP de Cascade pour voir son emplacement dans votre version) :

```json
{
  "mcpServers": {
    "twexapi": {
      "serverUrl": "https://api.twexapi.io/mcp",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}
```

## Autres clients

Tout client qui implémente l'autorisation MCP (OAuth 2.1 avec PKCE et enregistrement dynamique des clients) peut se connecter en ajoutant seulement l'URL du serveur. Sinon, envoyez votre clé API avec l'en-tête `x-api-key` ou `Authorization: Bearer YOUR_API_KEY`. Si vous créez votre propre client, consultez [OAuth pour les clients MCP](/mcp/oauth).

## Vérifier la connexion

- Le serveur affiche `explore`, `twexapi_request` et `twexapi_write`. `twexapi_write` n'apparaît pas si vous n'avez pas l'accès en écriture.
- Demandez à votre agent : « Utilise TwexAPI explore pour trouver les endpoints de tendances. » `explore` ne consomme aucun crédit : il fonctionne donc avant toute recharge.
- La nouvelle connexion apparaît sous **Authorized apps** (applications autorisées) dans le [tableau de bord](https://twexapi.io/dashboard).

| Problème | Solution |
| --- | --- |
| `401` ou « Needs authentication » | Relancez la connexion du client (`/mcp` dans Claude Code, **Authenticate** dans Cursor, `codex mcp login` ou `opencode mcp auth`). |
| La page de consentement indique qu'il n'y a pas de clé API | Créez une clé dans le tableau de bord, puis sélectionnez à nouveau **Approve** dans les 10 minutes. |
| La page de consentement indique qu'il n'y a pas de crédits | Rechargez, puis sélectionnez à nouveau **Approve** dans les 10 minutes. |
| Les appels d'outils renvoient « No credits left on this TwexAPI account » | Rechargez dans le tableau de bord. La connexion elle-même fonctionne. |
| `twexapi_write` est absent | Vous vous êtes connecté en lecture seule. Révoquez l'application dans le tableau de bord et reconnectez-vous en laissant la case d'écriture cochée. |

Lorsque vous signalez un problème, indiquez le nom et la version du client, l'heure UTC et, si vous pouvez le voir, l'en-tête de réponse `X-Request-Id`.