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

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

Connectez-vous à Brevo : accédez à votre tableau de bord Brevo
Allez dans les paramètres : cliquez sur votre profil → Paramètres
Ouvrez les clés API : sélectionnez « Clés API » dans le menu de gauche
Créez une nouvelle clé : cliquez sur « Générer une nouvelle clé API »
Nommez votre clé : donnez-lui un nom descriptif (par ex. « App de production », « Tests de développement »)
Définissez les permissions : choisissez le niveau d’accès approprié
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 :

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('@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

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

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é)

# .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é

Ne codez jamais les clés en dur

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

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

Utilisez des clés différentes par environnement

Production:  BREVO_API_KEY_PROD
Staging:     BREVO_API_KEY_STAGING
Development: BREVO_API_KEY_DEV

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

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

Révocation d’urgence d’une clé

Si une clé est compromise :

Révocation immédiate : supprimez la clé depuis le tableau de bord
Créer un remplacement : générez immédiatement une nouvelle clé
Mettre à jour les applications : déployez avec la nouvelle clé au plus vite
Surveiller l’activité : vérifiez s’il y a eu des usages non autorisés
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 pour le tableau complet.

En-têtes de rate limit

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

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)

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