---
title: "Chiavi API | Tajo"
description: "Guida completa all'autenticazione tramite chiave API con Brevo"
url: https://tajo.io/it/docs/authentication/api-keys/
markdown: https://tajo.io/it/docs/authentication/api-keys.md
lang: it-IT
author: "Set Noa"
author_url: https://tajo.io/it/set-noa/
robots: noindex
---

Richiedi l’accesso anticipato

Inserisci il tuo nome e indirizzo email aziendale. Ti invieremo un link per confermare la richiesta di accesso a Tajo.

# Chiavi API

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

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

1. **Accedi a Brevo**: apri la tua [dashboard Brevo](https://app.brevo.com/)
2. **Vai in Impostazioni**: clicca sul tuo profilo → Impostazioni
3. **Apri Chiavi API**: seleziona “Chiavi API” dal menu di sinistra
4. **Crea una nuova chiave**: clicca su “Genera una nuova chiave API”
5. **Assegna un nome**: dalle un nome descrittivo (ad es. “App di produzione”, “Test di sviluppo”)
6. **Imposta i permessi**: scegli il livello di accesso adeguato
7. **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`:

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

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

## Sicurezza delle chiavi API

### Archiviazione sicura

**Variabili d’ambiente** (consigliato)

```bash
# .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

1. **Non scrivere mai le chiavi nel codice**

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

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

2. **Usa chiavi diverse per ogni ambiente**

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

3. **Ruota le chiavi regolarmente**

   - Imposta promemoria per la rotazione trimestrale
   - Usa strumenti di automazione per la rotazione
   - Tieni pronto un piano di rollback

4. **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

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

### Revoca di emergenza di una chiave

Se una chiave viene compromessa:

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

## Rate limit e chiavi API

Brevo limita le richieste per endpoint, non per giorno. Nel livello generale, che ottengono tutti i piani, `POST /v3/smtp/email` consente 1.000 richieste al secondo, gli endpoint `/v3/contacts` ne consentono 10 al secondo e 36.000 all’ora, e gli endpoint senza un limite proprio ne consentono 100 all’ora. I piani Professional ed Enterprise sbloccano livelli superiori. Vedi [Limiti di frequenza](https://tajo.io/it/docs/rate-limits/) per la tabella completa.

### Header del rate limit

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

### Gestire il rate limit

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

## Risoluzione dei problemi con le chiavi API

### Messaggi di errore comuni

**Chiave API non valida (401)**

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

**Permessi insufficienti (403)**

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

**Rate limit superato (429)**

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

## Prossimi passi

- [Scopri OAuth 2.0](https://tajo.io/it/docs/authentication/oauth/)
- Comprendi i token JWT
- [Esplora i rate limit](https://tajo.io/it/docs/rate-limits/)
- [Prova gli SDK](https://tajo.io/it/docs/sdks-libraries/)