---
title: "Clés API | Tajo"
description: "Guide complet de l’authentification par clé API avec Brevo"
url: https://tajo.io/fr/docs/authentication/api-keys/
markdown: https://tajo.io/fr/docs/authentication/api-keys.md
lang: fr-FR
author: "Set Noa"
author_url: https://tajo.io/fr/set-noa/
robots: noindex
---

Demandez un accès anticipé

Indiquez votre prénom et votre adresse e-mail professionnelle. Nous vous enverrons un lien pour confirmer votre demande d’accès à Tajo.

# Clés API

[Set Noa](https://tajo.io/fr/set-noa/)

Les clés API sont la méthode principale pour s’authentifier auprès de l’API Brevo. Elles offrent un moyen simple et sécurisé d’accéder à votre compte de manière programmatique.

## Que sont les clés API ?

Les clés API sont des identifiants uniques qui authentifient votre application lorsqu’elle effectue des requêtes vers l’API Brevo. Chaque clé est une chaîne de 64 caractères qui sert à la fois d’identifiant et de mot de passe.

```
Example API key: xkeysib-a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456-Ab1Cd2Ef3Gh4
```

## Générer des clés API

### Guide étape par étape

1. **Connectez-vous à Brevo** : accédez à votre [tableau de bord Brevo](https://app.brevo.com/)
2. **Allez dans les paramètres** : cliquez sur votre profil → Paramètres
3. **Ouvrez les clés API** : sélectionnez « Clés API » dans le menu de gauche
4. **Créez une nouvelle clé** : cliquez sur « Générer une nouvelle clé API »
5. **Nommez votre clé** : donnez-lui un nom descriptif (par ex. « App de production », « Tests de développement »)
6. **Définissez les permissions** : choisissez le niveau d’accès approprié
7. **Générez** : cliquez sur « Générer » et copiez immédiatement la clé

### Conventions de nommage des clés API

Utilisez des noms descriptifs qui aident à identifier le rôle de la clé :

- `production-web-app`
- `staging-environment`
- `mobile-app-ios`
- `webhook-listener`
- `data-sync-service`

## Types et permissions des clés API

### Clés avec accès complet

```
Permissions: All API endpoints
Use cases: Complete application integration
Risk level: High - protect carefully
```

### Clés en lecture seule

```
Permissions: GET requests only
Use cases: Analytics, reporting, dashboards
Risk level: Low - limited access
```

### Clés d’envoi uniquement

```
Permissions: Transactional email sending
Use cases: Application notifications, receipts
Risk level: Medium - can send emails
```

### Clés de gestion des contacts

```
Permissions: Contact CRUD operations
Use cases: CRM integrations, form submissions
Risk level: Medium - data modification
```

## Utiliser les clés API

### Authentification par en-tête

Incluez votre clé API dans l’en-tête `api-key` :

```http
GET /v3/account HTTP/1.1
Host: api.brevo.com
Accept: application/json
Content-Type: application/json
api-key: YOUR_API_KEY
```

### Exemples de code

#### JavaScript/Node.js

```javascript
const brevo = require('@getbrevo/brevo');

const apiInstance = new brevo.AccountApi();
apiInstance.setApiKey(brevo.AccountApiApiKeys.apiKey, process.env.BREVO_API_KEY);

// Make authenticated request
apiInstance.getAccount()
  .then(data => console.log('Account info:', data))
  .catch(error => console.error('Error:', error));
```

#### Python

```python
import sib_api_v3_sdk
from sib_api_v3_sdk.rest import ApiException

# Configure API key
configuration = sib_api_v3_sdk.Configuration()
configuration.api_key['api-key'] = 'YOUR_API_KEY'

# Create API instance
api_instance = sib_api_v3_sdk.AccountApi(sib_api_v3_sdk.ApiClient(configuration))

try:
    # Get account info
    api_response = api_instance.get_account()
    print(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->get_account: %s\n" % e)
```

#### PHP

```php
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key
$config = SendinBlue\Client\Configuration::getDefaultConfiguration()->setApiKey('api-key', 'YOUR_API_KEY');

// Create API instance
$apiInstance = new SendinBlue\Client\Api\AccountApi(
    new GuzzleHttp\Client(),
    $config
);

try {
    $result = $apiInstance->getAccount();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->getAccount: ', $e->getMessage(), PHP_EOL;
}
?>
```

#### Ruby

```ruby
require 'sib-api-v3-sdk'

# Configure API key
SibApiV3Sdk.configure do |config|
  config.api_key['api-key'] = 'YOUR_API_KEY'
end

# Create API instance
api_instance = SibApiV3Sdk::AccountApi.new

begin
  # Get account info
  result = api_instance.get_account
  puts result
rescue SibApiV3Sdk::ApiError => e
  puts "Exception when calling AccountApi->get_account: #{e}"
end
```

## Sécurité des clés API

### Stockage sécurisé

**Variables d’environnement** (recommandé)

```bash
# .env file
BREVO_API_KEY=xkeysib-your-api-key-here

# Usage in code
const apiKey = process.env.BREVO_API_KEY;
```

**Gestionnaires de secrets cloud**

- AWS Secrets Manager
- Google Secret Manager
- Azure Key Vault
- HashiCorp Vault

### Bonnes pratiques de sécurité

1. **Ne codez jamais les clés en dur**

   ```javascript
   // ❌ Bad - hardcoded
   const apiKey = "xkeysib-a1b2c3d4...";

   // ✅ Good - environment variable
   const apiKey = process.env.BREVO_API_KEY;
   ```

2. **Utilisez des clés différentes par environnement**

   ```
   Production:  BREVO_API_KEY_PROD
   Staging:     BREVO_API_KEY_STAGING
   Development: BREVO_API_KEY_DEV
   ```

3. **Faites tourner les clés régulièrement**

   - Programmez des rappels de rotation trimestrielle
   - Utilisez des outils d’automatisation pour la rotation
   - Préparez un plan de retour en arrière

4. **Surveillez l’utilisation des clés**

   - Configurez des alertes en cas d’activité inhabituelle
   - Examinez les logs d’utilisation chaque mois
   - Suivez les schémas d’accès géographique

## Gestion des clés

### Suivi des clés actives

Surveillez vos clés actives dans le tableau de bord :

```
Key Name: production-web-app
Created: 2024-01-15
Last Used: 2024-01-20 14:30 UTC
Requests Today: 1,247
Status: Active
```

### Processus de rotation des clés

1. **Générer une nouvelle clé** : créez une clé de remplacement
2. **Mettre à jour la configuration** : déployez avec la nouvelle clé
3. **Surveiller** : assurez-vous que la nouvelle clé fonctionne correctement
4. **Période de grâce** : laissez l’ancienne clé active pendant 24 à 48 heures
5. **Révoquer l’ancienne clé** : supprimez la clé précédente

### Révocation d’urgence d’une clé

Si une clé est compromise :

1. **Révocation immédiate** : supprimez la clé depuis le tableau de bord
2. **Créer un remplacement** : générez immédiatement une nouvelle clé
3. **Mettre à jour les applications** : déployez avec la nouvelle clé au plus vite
4. **Surveiller l’activité** : vérifiez s’il y a eu des usages non autorisés
5. **Rapport d’incident** : documentez l’incident de sécurité

## Rate limiting et clés API

Brevo limite les requêtes par endpoint, et non par jour. Sur le palier général, que tous les forfaits obtiennent, `POST /v3/smtp/email` autorise 1 000 requêtes par seconde, les endpoints `/v3/contacts` en autorisent 10 par seconde et 36 000 par heure, et les endpoints sans limite propre en autorisent 100 par heure. Les forfaits Professional et Enterprise débloquent des paliers supérieurs. Consultez [Limites de débit](https://tajo.io/fr/docs/rate-limits/) pour le tableau complet.

### En-têtes de rate limit

```http
HTTP/1.1 200 OK
x-sib-ratelimit-limit: 1000
x-sib-ratelimit-remaining: 750
x-sib-ratelimit-reset: 1
```

### Gérer le rate limiting

```javascript
async function makeApiCall() {
  try {
    const response = await fetch(url, { headers });

    if (response.status === 429) {
      // Seconds until the window resets
      const waitTime = Number(response.headers.get('x-sib-ratelimit-reset') || 1);

      console.log(`Rate limited. Waiting ${waitTime} seconds`);
      await new Promise(resolve => setTimeout(resolve, waitTime * 1000));

      // Retry the request
      return makeApiCall();
    }

    return response.json();
  } catch (error) {
    console.error('API call failed:', error);
    throw error;
  }
}
```

## Résolution des problèmes de clés API

### Messages d’erreur courants

**Clé API invalide (401)**

```json
{
  "code": "unauthorized",
  "message": "Invalid API key provided"
}
```

**Permissions insuffisantes (403)**

```json
{
  "code": "permission_denied",
  "message": "API key does not have required permissions"
}
```

**Rate limit dépassé (429)**

```json
{
  "code": "too_many_requests",
  "message": "Rate limit exceeded for API key"
}
```

### Checklist de débogage

- La clé est correctement formatée (64 caractères)
- Pas d’espaces supplémentaires ni de caractères cachés
- La clé a les permissions requises
- La clé est active (non révoquée)
- Dans les limites de débit
- Utilisation du bon endpoint API
- En-têtes correctement formatés

## Prochaines étapes

- [En savoir plus sur OAuth 2.0](https://tajo.io/fr/docs/authentication/oauth/)
- Comprendre les tokens JWT
- [Explorer les limites de débit](https://tajo.io/fr/docs/rate-limits/)
- [Essayer les SDK](https://tajo.io/fr/docs/sdks-libraries/)