Richiedi l’accesso anticipato

Inserisci il tuo nome e un indirizzo email o un numero di telefono. Ti contatteremo con tutte le informazioni per accedere a Tajo.

Chiavi API

Le chiavi API sono il metodo principale per autenticarsi con l’API di Brevo. Offrono un modo semplice e sicuro per accedere al tuo account a livello programmatico.

Cosa sono le chiavi API?

Le chiavi API sono identificatori univoci che autenticano la tua applicazione quando effettua richieste all’API di Brevo. Ogni chiave è una stringa di 64 caratteri che funge sia da identificatore sia da password.

Example API key: xkeysib-a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456-Ab1Cd2Ef3Gh4

Generare chiavi API

Guida passo passo

Accedi a Brevo: apri la tua dashboard Brevo
Vai in Impostazioni: clicca sul tuo profilo → Impostazioni
Apri Chiavi API: seleziona “Chiavi API” dal menu di sinistra
Crea una nuova chiave: clicca su “Genera una nuova chiave API”
Assegna un nome: dalle un nome descrittivo (ad es. “App di produzione”, “Test di sviluppo”)
Imposta i permessi: scegli il livello di accesso adeguato
Genera: clicca su “Genera” e copia subito la chiave

Convenzioni di nomenclatura delle chiavi API

Usa nomi descrittivi che aiutino a identificare lo scopo della chiave:

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

Tipi e permessi delle chiavi API

Chiavi ad accesso completo

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

Chiavi in sola lettura

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

Chiavi solo invio

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

Chiavi per la gestione dei contatti

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

Usare le chiavi API

Autenticazione tramite header

Includi la tua chiave API nell’header api-key:

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

Esempi di codice

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

Sicurezza delle chiavi API

Archiviazione sicura

Variabili d’ambiente (consigliato)

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

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

Secret manager cloud

AWS Secrets Manager
Google Secret Manager
Azure Key Vault
HashiCorp Vault

Best practice di sicurezza

Non scrivere mai le chiavi nel codice

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

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

Usa chiavi diverse per ogni ambiente

Production:  BREVO_API_KEY_PROD
Staging:     BREVO_API_KEY_STAGING
Development: BREVO_API_KEY_DEV

Ruota le chiavi regolarmente
- Imposta promemoria per la rotazione trimestrale
- Usa strumenti di automazione per la rotazione
- Tieni pronto un piano di rollback
Monitora l’uso delle chiavi
- Configura alert per attività anomale
- Esamina i log di utilizzo ogni mese
- Tieni traccia degli schemi di accesso geografico

Gestione delle chiavi

Monitoraggio delle chiavi attive

Controlla le chiavi attive nella dashboard:

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

Processo di rotazione delle chiavi

Genera una nuova chiave: crea una chiave sostitutiva
Aggiorna la configurazione: distribuisci con la nuova chiave
Monitora: verifica che la nuova chiave funzioni correttamente
Periodo di grazia: mantieni attiva la vecchia chiave per 24–48 ore
Revoca la vecchia chiave: elimina la chiave precedente

Revoca di emergenza di una chiave

Se una chiave viene compromessa:

Revoca immediata: elimina la chiave dalla dashboard
Crea una sostituta: genera subito una nuova chiave
Aggiorna le applicazioni: distribuisci la nuova chiave appena possibile
Monitora l’attività: verifica eventuali utilizzi non autorizzati
Report d’incidente: documenta l’incidente di sicurezza

Rate limit e chiavi API

Ogni chiave API ha limiti di richiesta individuali:

Piano Free: 300 richieste/giorno
Piano Starter: 20.000 richieste/giorno
Piano Business: 50.000 richieste/giorno
Piano Enterprise: limiti personalizzati

Header del rate limit

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

Gestire il rate limit

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

Risoluzione dei problemi con le chiavi API

Messaggi di errore comuni

Chiave API non valida (401)

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

Permessi insufficienti (403)

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

Rate limit superato (429)

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

Checklist di debug

La chiave è formattata correttamente (64 caratteri)
Nessuno spazio aggiuntivo o carattere nascosto
La chiave ha i permessi necessari
La chiave è attiva (non revocata)
Entro i limiti di richiesta
Uso dell’endpoint API corretto
Header formattati correttamente