---
title: "Claves de API | Tajo"
description: "Guía completa de la autenticación con claves de API en Brevo"
url: https://tajo.io/es/docs/authentication/api-keys/
markdown: https://tajo.io/es/docs/authentication/api-keys.md
lang: es-ES
author: "Set Noa"
author_url: https://tajo.io/es/set-noa/
robots: noindex
---

Solicita acceso anticipado

Escribe tu nombre y dirección de correo de trabajo. Te enviaremos un enlace para confirmar tu solicitud de acceso a Tajo.

# Claves de API

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

Las claves de API son el método principal para autenticarte en la API de Brevo. Ofrecen una forma sencilla y segura de acceder a tu cuenta de manera programática.

## ¿Qué son las claves de API?

Las claves de API son identificadores únicos que autentican tu aplicación cuando envía peticiones a la API de Brevo. Cada clave es una cadena de 64 caracteres que funciona a la vez como identificador y como contraseña.

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

## Generar claves de API

### Guía paso a paso

1. **Inicia sesión en Brevo**: entra en tu [panel de control de Brevo](https://app.brevo.com/)
2. **Ve a la configuración**: haz clic en tu perfil → Configuración
3. **Abre API Keys**: selecciona “API Keys” en el menú de la izquierda
4. **Crea una clave nueva**: haz clic en “Generate a New API Key”
5. **Ponle nombre a la clave**: dale un nombre descriptivo (por ejemplo, “Production App” o “Development Testing”)
6. **Define los permisos**: elige el nivel de acceso adecuado
7. **Genera**: haz clic en “Generate” y copia la clave de inmediato

### Convenciones de nombres para las claves de API

Usa nombres descriptivos que te ayuden a identificar para qué sirve cada clave:

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

## Tipos de claves de API y permisos

### Claves de acceso completo

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

### Claves de solo lectura

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

### Claves de solo envío

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

### Claves de gestión de contactos

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

## Usar las claves de API

### Autenticación por cabecera

Incluye tu clave de API en la cabecera `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
```

### Ejemplos de código

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

## Seguridad de las claves de API

### Almacenamiento seguro

**Variables de entorno** (recomendado)

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

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

**Gestores de secretos en la nube**

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

### Buenas prácticas de seguridad

1. **Nunca escribas las claves en el código**

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

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

2. **Usa una clave distinta en cada entorno**

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

3. **Rota las claves con regularidad**

   - Programa recordatorios en el calendario para rotarlas cada trimestre
   - Usa herramientas de automatización para la rotación de claves
   - Ten preparado un plan de reversión

4. **Vigila el uso de las claves**

   - Configura alertas para detectar actividad inusual
   - Revisa cada mes los registros de uso de las claves
   - Haz seguimiento de los patrones de acceso por ubicación geográfica

## Gestión de claves

### Monitorización de las claves activas

Consulta tus claves activas en el panel de control:

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

### Proceso de rotación de claves

1. **Genera una clave nueva**: crea la clave que sustituirá a la anterior
2. **Actualiza la configuración**: despliega con la clave nueva
3. **Monitoriza**: asegúrate de que la clave nueva funciona correctamente
4. **Periodo de gracia**: mantén activa la clave antigua entre 24 y 48 horas
5. **Revoca la clave antigua**: elimina la clave anterior

### Revocación de emergencia

Si una clave queda expuesta:

1. **Revocación inmediata**: elimina la clave desde el panel de control
2. **Genera una sustituta**: crea una clave nueva de inmediato
3. **Actualiza tus aplicaciones**: despliega con la clave nueva cuanto antes
4. **Vigila la actividad**: comprueba si ha habido usos no autorizados
5. **Informe del incidente**: documenta el incidente de seguridad

## Límites de peticiones y claves de API

Brevo limita las peticiones por endpoint, no por día. En el nivel general, que obtienen todos los planes, `POST /v3/smtp/email` permite 1.000 peticiones por segundo, los endpoints de `/v3/contacts` permiten 10 por segundo y 36.000 por hora, y los endpoints sin límite propio permiten 100 por hora. Los planes Professional y Enterprise desbloquean niveles superiores. Consulta [Límites de tasa](https://tajo.io/es/docs/rate-limits/) para ver la tabla completa.

### Cabeceras de límite de peticiones

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

### Gestionar los límites de peticiones

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

## Solución de problemas con las claves de API

### Mensajes de error habituales

**Clave de API no válida (401)**

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

**Permisos insuficientes (403)**

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

**Límite de peticiones superado (429)**

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

### Lista de comprobación para depurar

- La clave tiene el formato correcto (64 caracteres)
- No hay espacios de más ni caracteres ocultos
- La clave tiene los permisos necesarios
- La clave está activa (no revocada)
- Estás dentro de los límites de peticiones
- Usas el endpoint de API correcto
- Las cabeceras tienen el formato correcto

## Próximos pasos

- [Más información sobre OAuth 2.0](https://tajo.io/es/docs/authentication/oauth/)
- Comprender los tokens JWT
- [Explora los límites de peticiones](https://tajo.io/es/docs/rate-limits/)
- [Prueba los SDK](https://tajo.io/es/docs/sdks-libraries/)