On this page

Clés API

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.

Exemple de clé API : 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
  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 : tous les endpoints de l'API
Cas d'usage : intégration complète d'une application
Niveau de risque : élevé, protégez-les soigneusement

Clés en lecture seule 

Permissions : requêtes GET uniquement
Cas d'usage : analytics, reporting, tableaux de bord
Niveau de risque : faible, accès limité

Clés d’envoi uniquement 

Permissions : envoi d'e-mails transactionnels
Cas d'usage : notifications applicatives, reçus
Niveau de risque : moyen, peut envoyer des e-mails

Clés de gestion des contacts 

Permissions : opérations CRUD sur les contacts
Cas d'usage : intégrations CRM, soumissions de formulaires
Niveau de risque : moyen, modification des données

Utiliser les clés API

Authentification par en-tête

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

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 

const brevo = require('@brevo/api');


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


// Effectuer une requête authentifiée
apiInstance.getAccount()
  .then(data => console.log('Infos du compte :', data))
  .catch(error => console.error('Erreur :', error));

Python 

import sib_api_v3_sdk
from sib_api_v3_sdk.rest import ApiException


# Configurer la clé API
configuration = sib_api_v3_sdk.Configuration()
configuration.api_key['api-key'] = 'YOUR_API_KEY'


# Créer une instance d'API
api_instance = sib_api_v3_sdk.AccountApi(sib_api_v3_sdk.ApiClient(configuration))


try:
    # Obtenir les infos du compte
    api_response = api_instance.get_account()
    print(api_response)
except ApiException as e:
    print("Exception lors de l'appel à AccountApi->get_account : %s\n" % e)

PHP 

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


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


// Créer une instance d'API
$apiInstance = new SendinBlue\Client\Api\AccountApi(
    new GuzzleHttp\Client(),
    $config
);


try {
    $result = $apiInstance->getAccount();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception lors de l\'appel à AccountApi->getAccount : ', $e->getMessage(), PHP_EOL;
}
?>

Ruby 

require 'sib-api-v3-sdk'


# Configurer la clé API
SibApiV3Sdk.configure do |config|
  config.api_key['api-key'] = 'YOUR_API_KEY'
end


# Créer une instance d'API
api_instance = SibApiV3Sdk::AccountApi.new


begin
  # Obtenir les infos du compte
  result = api_instance.get_account
  puts result
rescue SibApiV3Sdk::ApiError => e
  puts "Exception lors de l'appel à AccountApi->get_account : #{e}"
end

Sécurité des clés API

Stockage sécurisé

Variables d’environnement (recommandé)

Terminal window
# Fichier .env
BREVO_API_KEY=xkeysib-your-api-key-here


# Utilisation dans le 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

    // ❌ Mauvais, en dur
    const apiKey = "xkeysib-a1b2c3d4...";
    

    // ✅ Bien, variable d'environnement
    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
    Développement : 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 :

Nom de la clé : production-web-app
Créée le : 2024-01-15
Dernière utilisation : 2024-01-20 14:30 UTC
Requêtes aujourd'hui : 1 247
Statut : 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

Chaque clé API dispose de ses propres limites de requêtes :

  • Plan Gratuit : 300 requêtes/jour
  • Plan Starter : 20 000 requêtes/jour
  • Plan Business : 50 000 requêtes/jour
  • Plan Enterprise : limites personnalisées

En-têtes de rate limit 

HTTP/1.1 200 OK
X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 999
X-RateLimit-Reset: 1640995200

Gérer le rate limiting 

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


    if (response.status === 429) {
      const resetTime = response.headers.get('X-RateLimit-Reset');
      const waitTime = resetTime - Math.floor(Date.now() / 1000);


      console.log(`Rate limit atteint. Attente ${waitTime} secondes`);
      await new Promise(resolve => setTimeout(resolve, waitTime * 1000));


      // Relancer la requête
      return makeApiCall();
    }


    return response.json();
  } catch (error) {
    console.error('Échec de l\'appel API :', error);
    throw error;
  }
}

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

Messages d’erreur courants

Clé API invalide (401)

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

Permissions insuffisantes (403)

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

Rate limit dépassé (429)

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

Assistant AI

Bonjour ! Posez-moi vos questions sur la documentation.

Commencez gratuitement avec Brevo