---
title: "Authentification"
description: "Authentification par jeton Bearer pour Twexapi — à utiliser avec Cursor, Claude Code, GitHub Copilot, ChatGPT et des agents de codage IA. Commencez en quelques minutes."
---

## **Authentification API**

Twexapi utilise l'authentification par jeton Bearer pour sécuriser toutes les demandes API. Chaque demande doit inclure une clé API valide dans l'en-tête d'autorisation pour accéder à nos points de terminaison.

## Obtenir Votre Clé API

Suivez ces étapes simples pour obtenir votre clé API :

1. Connectez-vous à votre [Tableau de bord Twexapi](https://twexapi.io/dashboard)
2. Votre clé API unique sera affichée en bonne place sur la page d'accueil du tableau de bord
3. Copiez la clé en toute sécurité - vous en aurez besoin pour toutes les demandes API

:::tip
Conservez votre clé API en sécurité et ne la dévoilez jamais dans le code client ou dans des dépôts publics.
:::

---

## Utiliser Votre Clé API

Incluez votre clé API dans l'en-tête `Authorization` de chaque demande en utilisant le format de jeton Bearer :

**En-tête Requis :**

```bash
Authorization: Bearer VOTRE_CLÉ_API
```

---

## Variable d'environnement

Les SDK et la CLI lisent la même credential à partir de l'environnement :

```bash
export X_API_SCRAPER_KEY="VOTRE_CLÉ_API"
```

Utilisez `Authorization: Bearer VOTRE_CLÉ_API` dans les demandes HTTP brutes. Les SDK générés acceptent `bearer_auth` ou une option équivalente — voir chaque [page SDK](/sdks).

---

## Authentification avec la CLI

Installez la CLI officielle, enregistrez votre clé API en tant que profil d'application nommé, et exécutez des commandes sans intégrer de secrets dans l'historique du shell :

```bash
npm install -g @twexapi-dev/x-api-scraper-cli

export X_API_SCRAPER_KEY="VOTRE_CLÉ_API"

x-api-scraper auth apps add --name prod --api-key "VOTRE_CLÉ_API"
x-api-scraper auth apps use prod
x-api-scraper --app prod about elonmusk
```

Référence complète des commandes : [CLI](/sdks/cli).

---

## Authentification avec MCP

Connectez les agents IA à `https://api.twexapi.io/mcp` avec votre clé API :

```json
{
  "headers": {
    "x-api-key": "VOTRE_CLÉ_API"
  }
}
```

Certains clients acceptent `Authorization: Bearer VOTRE_CLÉ_API` à la place. Consultez [Serveur MCP](/mcp/overview) pour Cursor, Claude Code, Codex CLI et d'autres configurations clients.

---

## Authentification avec des Agents de Codage IA

Installez l'habilité TwexAPI pour que **Cursor**, **Claude Code**, **GitHub Copilot**, **ChatGPT**, **Cline**, **Windsurf**, **Codex**, **Gemini CLI**, **Continue**, **Roo Code** et d'autres assistants IA sachent comment attacher correctement les jetons Bearer. Des guides de configuration et des options CLI sont disponibles sur le [centre d'intégrations](https://twexapi.io/integrations).

:::tip
Copiez votre clé API à partir du [tableau de bord](https://twexapi.io/dashboard), stockez-la dans `X_API_SCRAPER_KEY` ou dans un fichier `.env`, et demandez à votre agent de configurer `Authorization: Bearer VOTRE_CLÉ_API` — l'habilité couvre le schéma d'authentification pour cURL, Python, JavaScript et la CLI.
:::

```bash
npx skills add twexapi-dev/x-api-scraper-cli
```

Dans Cursor, GitHub Copilot, Claude Code, ChatGPT, Continue, Roo Code ou tout autre agent pris en charge, essayez des prompts comme *"configurez l'authentification Twexapi à partir de mon fichier `.env`"*, *"ajoutez l'authentification Bearer à ce client API"*, ou *"générez une demande de test avec ma clé API"*.

---

## Opérations d'écriture et BYOC (Bring Your Own Cookie)

Bien que tous les points de terminaison de lecture publics (recherche, profils d'utilisateur, tweets, abonnés, fils, tendances) nécessitent **zéro cookies ou informations de connexion Twitter**, les actions d'écriture fonctionnent sous un modèle **BYOC (Bring Your Own Cookie)**.

### Actions d'écriture Prises en Charge

- Création de tweets et de publications de fils (`POST /twitter/tweets/create`, `POST /v3/twitter/tweets/create_thread`)
- Aimentation et retweet (`POST /twitter/tweets/{tweet_id}/like`, `POST /twitter/tweets/{tweet_id}/retweet`)
- Envoi de messages directs (`POST /v3/twitter/send_dm`)
- Suivi de comptes (`POST /twitter/user/follow`)

### Exécution Déléguée et Sécurité Zero-Retention

<CardGroup cols={2}>
  <Card title="Autorisation Propriétaire de l'Utilisateur" icon="user-check">
    Vous passez votre propre chaîne `auth_token` ou cookie de compte. TwexAPI agit strictement en tant que passerelle d'exécution sans état pour votre compte.
  </Card>
  <Card title="Gestion Zero-Credential" icon="shield-halved">
    Les jetons de session sont conservés strictement dans la mémoire serveur éphémère pendant l'exécution de cette demande HTTP spécifique. Ils ne sont jamais enregistrés sur le disque ou dans les bases de données.
  </Card>
  <Card title="Protection Légale et de Contenu Complète" icon="scale">
    Comme les actions sont exécutées avec vos informations de compte autorisées explicitement, votre équipe conserve la pleine propriété intellectuelle et élimine les responsabilités d'impersonation tierce.
  </Card>
  <Card title="Pas de Contamination de Compte Partagé" icon="lock">
    TwexAPI n'utilise jamais de comptes brûlés poolés, recyclés ou partagés pour les opérations d'écriture. Vos actions sont complètement isolées à vos propres comptes.
  </Card>
</CardGroup>

### Comment Authentifier les Demandes d'Écriture

En plus de l'en-tête `Authorization: Bearer VOTRE_CLÉ_API`, fournissez la chaîne `auth_token` ou le cookie de votre compte directement dans le corps de la demande :

```bash
curl -X POST "https://api.twexapi.io/twitter/tweets/create" \
  -H "Authorization: Bearer VOTRE_CLÉ_API" \
  -H "Content-Type: application/json" \
  -d '{
    "tweet_text": "Bonjour monde depuis un pipeline automatisé !",
    "cookie": "auth_token=VOTRE_TOKEN_AUTH_TWITTER; ct0=VOTRE_TOKEN_CT0"
  }'
```

:::tip Extraction de Votre auth_token
Pour obtenir votre chaîne `auth_token`, ouvrez les outils de développement du navigateur (`F12`), accédez à **Application > Stockage > Cookies > https://x.com**, et copiez la valeur du cookie `auth_token`.
:::

---

## **Exemples d'Implementation**

Voici des exemples pratiques montrant comment authentifier vos demandes dans différentes langues de programmation :

:::note
Remplacez `VOTRE_CLÉ_API` par votre clé API réelle du tableau de bord. Tous les exemples récupèrent des informations utilisateur à des fins de démonstration.
:::

### cURL

Parfait pour les tests et l'exploration rapide de l'API :

```bash
curl --request GET \
  --url 'https://api.twexapi.io/twitter/users?usernames=elonmusk' \
  --header 'Authorization: Bearer VOTRE_CLÉ_API' \
  --header 'Content-Type: application/json'
```

### Python

En utilisant la populaire bibliothèque `requests` :

```python
import requests

# Point de terminaison API et paramètres
url = "https://api.twexapi.io/twitter/users"
params = {"usernames": "elonmusk"}

# En-tête d'authentification
headers = {
    "Authorization": "Bearer VOTRE_CLÉ_API",
    "Content-Type": "application/json"
}

# Effectuer la demande
response = requests.get(url, headers=headers, params=params)

# Gérer la réponse
if response.status_code == 200:
    data = response.json()
    print(data)
else:
    print(f"Erreur : {response.status_code} - {response.text}")
```

### JavaScript (Node.js/Browser)

Implémentation moderne de l'API fetch :

```javascript
const fetchUserData = async () => {
  const options = {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer VOTRE_CLÉ_API',
      'Content-Type': 'application/json'
    }
  };

  try {
    const response = await fetch(
      'https://api.twexapi.io/twitter/users?usernames=elonmusk', 
      options
    );
    
    if (!response.ok) {
      throw new Error(`Erreur HTTP ! statut : ${response.status}`);
    }
    
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Demande échouée :', error);
  }
};

fetchUserData();
```

### Java

En utilisant Unirest pour des demandes HTTP simplifiées :

```java
import kong.unirest.HttpResponse;
import kong.unirest.Unirest;

public class TwitterApiExample {
    public static void main(String[] args) {
        try {
            HttpResponse<String> response = Unirest
                .get("https://api.twexapi.io/twitter/users?usernames=elonmusk")
                .header("Authorization", "Bearer VOTRE_CLÉ_API")
                .header("Content-Type", "application/json")
                .asString();
            
            if (response.getStatus() == 200) {
                System.out.println(response.getBody());
            } else {
                System.err.println("Erreur : " + response.getStatus() + " - " + response.getBody());
            }
        } catch (Exception e) {
            System.err.println("Demande échouée : " + e.getMessage());
        }
    }
}
```

## **Meilleures Pratiques et Prochaines Étapes**

- **Variables d'Environnement** : Stockez votre clé API dans `X_API_SCRAPER_KEY` ou un gestionnaire de secrets, ne la codez jamais en dur.
- **Facturation Transparente** : Consultez les tarifs micro par demande dans notre [Guide de Tarification et Facturation](/guides/pricing).
- **Recovery des Erreurs** : Gérez les réponses `4xx`/`5xx` — voir [Gestion des Erreurs](/guides/error-handling).
- **Limits de Taux** : Réduisez les demandes lors des `429` — voir [Limits de Taux](/guides/rate-limits).
- **Lecture Publique Zero-Cookie** : Comprenez pourquoi aucun cookie de connexion Twitter n'est nécessaire par rapport aux configurations auto-hébergées dans [Auto-Scrappeur vs TwexAPI](/comparison/scraper-vs-api) et [Alternatives à Nitter](/comparison/nitter-alternatives).
- **Évaluation de l'Architecture** : Comparez TwexAPI avec l'API X officielle (Pay-as-you-go par ressource vs par demande) dans notre [Comparaison de l'API X Officielle](/comparison/official-x-api).
- **HTTPS Seulement** : Toutes les demandes doivent utiliser HTTPS pour la sécurité.