# Claves de API API

> Crea, lista, renombra y revoca las claves de API de un espacio de trabajo.

URL base: `https://api.emailit.com/v2`. Autentícate con `Authorization: Bearer <API key>`.

## Crear una clave de API — POST /api-keys

> Crea una clave de API full o sending para el espacio de trabajo, limitada opcionalmente a un dominio de envío. El secreto solo se devuelve una vez.

# Crear una clave de API

Crea una clave de API y devuelve su secreto.

`POST /api-keys`

Requiere una clave de API `full`. El secreto de `key` solo se devuelve en esta respuesta y cuando [regeneras](/es/docs/api-reference/api-keys/regenerate/) la clave, así que guárdalo de forma segura enseguida. La clave también sirve como contraseña SMTP. Para saber qué permite cada permiso, consulta [Autenticación](/es/docs/api-reference/authentication/).

## Parámetros del cuerpo

- `name` (string, obligatorio): Un nombre que indique dónde se usa la clave, como `Production web app`. Debe ser único entre las claves del espacio de trabajo.

- `scope` (string): `full` para acceder a todos los endpoints, o `sending` para acceder solo a los endpoints de envío. No se puede cambiar después.

- `sending_domain_id` (string): El ID de un dominio de envío (`dom_…`) al que limitar una clave `sending`. Así, la clave solo puede enviar desde direcciones de ese dominio. Se ignora en las claves `full`.

## Devuelve

Devuelve `201` con el [objeto de clave de API](/es/docs/api-reference/api-keys/get/) y su secreto:

- `key` (string): El secreto, que empieza por `secret_`. Úsalo como token Bearer. No se vuelve a mostrar.

**Petición** `POST /api-keys`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const apiKey = await emailit.apiKeys.create({
  name: 'Production web app',
  scope: 'sending',
});
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

api_key = client.api_keys.create({
  "name": "Production web app",
  "scope": "sending",
})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$apiKey = $emailit->apiKeys()->create([
  'name' => 'Production web app',
  'scope' => 'sending',
]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

api_key = client.api_keys.create(
  name: "Production web app",
  scope: "sending"
)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

apiKey, err := client.ApiKeys.Create(&emailit.CreateApiKeyRequest{
  Name:  "Production web app",
  Scope: "sending",
})
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let api_key = emailit.api_keys.create(
  emailit::types::CreateApiKeyParams::new("Production web app")
    .with_scope("sending")
).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject apiKey = emailit.apiKeys().create(
  ApiKeyCreateParams.builder()
    .setName("Production web app")
    .setScope("sending")
    .build()
);
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var apiKey = emailit.ApiKeys.Create(new ApiKeyCreateOptions {
  Name = "Production web app",
  Scope = "sending",
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$apiKey = Emailit::apiKeys()->create([
  'name' => 'Production web app',
  'scope' => 'sending',
]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/api-keys \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Production web app",
    "scope": "sending"
  }'
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/api-keys \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Production web app",
    "scope": "sending",
    "sending_domain_id": "dom_4K468YrjOkR1wwdhqiO0G9XEUey"
  }'
```

**Node.js**

```javascript
const apiKey = await emailit.apiKeys.create({
  name: 'Production web app',
  scope: 'sending',
  sending_domain_id: 'dom_4K468YrjOkR1wwdhqiO0G9XEUey',
});
```

**Python**

```python
api_key = client.api_keys.create({
  "name": "Production web app",
  "scope": "sending",
  "sending_domain_id": "dom_4K468YrjOkR1wwdhqiO0G9XEUey",
})
```

**201**

```json
{
  "object": "api_key",
  "id": "key_4KEaYMnfrxQGkuB0svwiuyt0ZhB",
  "name": "Production web app",
  "scope": "sending",
  "sending_domain_id": "dom_4K468YrjOkR1wwdhqiO0G9XEUey",
  "last_used_at": null,
  "created_at": "2026-10-01T09:40:18.204917Z",
  "updated_at": "2026-10-01T09:40:18.204917Z",
  "key": "secret_Xq7pL2mN9vB4kR8tW1yZ6cH3jF5dS0aG"
}
```

**400**

```json
{
  "error": "Invalid sending_domain_id. Domain not found in workspace"
}
```

**409**

```json
{
  "error": "API key with this name already exists",
  "existing": {
    "object": "api_key",
    "id": "key_4Kw6E8FodRivXbJlwPdn79gOxi1",
    "name": "Production web app"
  }
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/api-keys/create/

## Obtener una clave de API — GET /api-keys/{id}

> Obtén una clave de API por su ID o su nombre, con su permiso, su limitación a un dominio y cuándo se usó por última vez. El secreto nunca se devuelve.

# Obtener una clave de API

Obtiene los detalles de una clave de API. No incluye el secreto.

`GET /api-keys/{id}`

Requiere una clave de API `full`. Las claves eliminadas no se encuentran.

## Parámetros de ruta

- `id` (string, obligatorio): El ID de la clave de API (`key_…`) o su nombre. Codifica para URL los nombres con espacios.

## Devuelve

Devuelve el objeto de clave de API.

- `object` (string): Siempre `api_key`.

- `id` (string): El ID de la clave de API.

- `name` (string): El nombre de la clave.

- `scope` (string): `full` o `sending`.

- `sending_domain_id` (string | null): El ID del dominio de envío al que está limitada la clave, o `null`.

- `last_used_at` (string | null): Cuándo autenticó la clave una petición por última vez, o `null` si no se ha usado desde que se creó o se regeneró.

- `created_at` (string): Cuándo se creó la clave.

- `updated_at` (string): Cuándo se renombró o se regeneró la clave por última vez.

**Petición** `GET /api-keys/{id}`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const apiKey = await emailit.apiKeys.get('key_4KEaYMnfrxQGkuB0svwiuyt0ZhB');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

api_key = client.api_keys.get("key_4KEaYMnfrxQGkuB0svwiuyt0ZhB")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$apiKey = $emailit->apiKeys()->get('key_4KEaYMnfrxQGkuB0svwiuyt0ZhB');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

api_key = client.api_keys.get("key_4KEaYMnfrxQGkuB0svwiuyt0ZhB")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

apiKey, err := client.ApiKeys.Get("key_4KEaYMnfrxQGkuB0svwiuyt0ZhB")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let api_key = emailit.api_keys.get("key_4KEaYMnfrxQGkuB0svwiuyt0ZhB").await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject apiKey = emailit.apiKeys().get("key_4KEaYMnfrxQGkuB0svwiuyt0ZhB");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var apiKey = emailit.ApiKeys.Get("key_4KEaYMnfrxQGkuB0svwiuyt0ZhB");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$apiKey = Emailit::apiKeys()->get('key_4KEaYMnfrxQGkuB0svwiuyt0ZhB');
```

**cURL**

```bash
curl https://api.emailit.com/v2/api-keys/key_4KEaYMnfrxQGkuB0svwiuyt0ZhB \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "api_key",
  "id": "key_4KEaYMnfrxQGkuB0svwiuyt0ZhB",
  "name": "Production web app",
  "scope": "sending",
  "sending_domain_id": "dom_4K468YrjOkR1wwdhqiO0G9XEUey",
  "last_used_at": "2026-10-01T11:58:02.000000Z",
  "created_at": "2026-10-01T09:40:18.204917Z",
  "updated_at": "2026-10-01T09:40:18.204917Z"
}
```

**404**

```json
{
  "error": "API key not found"
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/api-keys/get/

## Listar claves de API — GET /api-keys

> Lista las claves de API de un espacio de trabajo con su permiso, su limitación a un dominio y su último uso, de la más reciente a la más antigua. Nunca incluye los secretos.

# Listar claves de API

Devuelve una página de claves de API del espacio de trabajo, de la más reciente a la más antigua.

`GET /api-keys`

Requiere una clave de API `full`. No incluye las claves eliminadas ni los secretos. Comprueba `last_used_at` para encontrar las claves que ya no usas.

## Parámetros de consulta

- `page` (integer): La página que se devuelve.

- `limit` (integer): Claves por página, de 1 a 100.

- `search` (string): Búsqueda en el nombre de la clave, sin distinguir mayúsculas y minúsculas.

- `match` (string): `all` u `or`. Cómo se combinan los filtros que se indican abajo.

- `order` (string): Una clave de filtro por la que ordenar.

- `direction` (string): `asc` o `desc`.

## Filtros

Añade filtros con el formato `key.condition=value`, por ejemplo `scope.exact=sending`. Consulta [Filtrado](/es/docs/api-reference/filtering/).

| Clave | Tipo | Notas |
| --- | --- | --- |
| `name` | cadena | |
| `scope` | cadena | `full` o `sending`. |
| `type` | cadena | Tipo de credencial. Las claves creadas en el panel o con la API son `api`. |
| `created_at` | fecha | |

Todas las claves de filtro son también claves de ordenación.

## Devuelve

Devuelve un array `data` de [objetos de clave de API](/es/docs/api-reference/api-keys/get/) con `next_page_url` y `previous_page_url`. Consulta [Paginación](/es/docs/api-reference/pagination/).

**Petición** `GET /api-keys`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const apiKeys = await emailit.apiKeys.list();
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

api_keys = client.api_keys.list()
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$apiKeys = $emailit->apiKeys()->list();
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

api_keys = client.api_keys.list
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

apiKeys, err := client.ApiKeys.List(nil)
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let api_keys = emailit.api_keys.list(None).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject apiKeys = emailit.apiKeys().list();
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var apiKeys = emailit.ApiKeys.List();
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$apiKeys = Emailit::apiKeys()->list();
```

**cURL**

```bash
curl https://api.emailit.com/v2/api-keys \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "data": [
    {
      "object": "api_key",
      "id": "key_4KEaYMnfrxQGkuB0svwiuyt0ZhB",
      "name": "Production web app",
      "scope": "sending",
      "sending_domain_id": "dom_4K468YrjOkR1wwdhqiO0G9XEUey",
      "last_used_at": "2026-10-01T11:58:02.000000Z",
      "created_at": "2026-10-01T09:40:18.204917Z",
      "updated_at": "2026-10-01T09:40:18.204917Z"
    },
    {
      "object": "api_key",
      "id": "key_4Kw6E8FodRivXbJlwPdn79gOxi1",
      "name": "Back office",
      "scope": "full",
      "sending_domain_id": null,
      "last_used_at": null,
      "created_at": "2026-09-02T14:21:07.613508Z",
      "updated_at": "2026-09-02T14:21:07.613508Z"
    }
  ],
  "next_page_url": null,
  "previous_page_url": null
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/api-keys/list/

## Actualizar una clave de API — POST /api-keys/{id}

> Cambia el nombre de una clave de API. El secreto, el permiso y la limitación a un dominio no cambian; para cambiarlos, crea una clave nueva o regenera el secreto.

# Actualizar una clave de API

Cambia el nombre de una clave de API.

`POST /api-keys/{id}`

Requiere una clave de API `full`. Solo se puede cambiar el nombre. Para cambiar el permiso o la limitación a un dominio, [crea una clave nueva](/es/docs/api-reference/api-keys/create/) y elimina esta. Para sustituir el secreto, [regenéralo](/es/docs/api-reference/api-keys/regenerate/).

## Parámetros de ruta

- `id` (string, obligatorio): El ID de la clave de API o su nombre actual.

## Parámetros del cuerpo

- `name` (string, obligatorio): El nombre nuevo. Debe ser único entre las claves del espacio de trabajo.

## Devuelve

Devuelve el [objeto de clave de API](/es/docs/api-reference/api-keys/get/) actualizado.

**Petición** `POST /api-keys/{id}`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const apiKey = await emailit.apiKeys.update('key_4KEaYMnfrxQGkuB0svwiuyt0ZhB', {
  name: 'Production web app (EU)',
});
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

api_key = client.api_keys.update("key_4KEaYMnfrxQGkuB0svwiuyt0ZhB", {
  "name": "Production web app (EU)",
})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$apiKey = $emailit->apiKeys()->update('key_4KEaYMnfrxQGkuB0svwiuyt0ZhB', [
  'name' => 'Production web app (EU)',
]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

api_key = client.api_keys.update("key_4KEaYMnfrxQGkuB0svwiuyt0ZhB", name: "Production web app (EU)")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

apiKey, err := client.ApiKeys.Update("key_4KEaYMnfrxQGkuB0svwiuyt0ZhB", &emailit.UpdateApiKeyRequest{
  Name: "Production web app (EU)",
})
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let api_key = emailit.api_keys.update("key_4KEaYMnfrxQGkuB0svwiuyt0ZhB",
  emailit::types::UpdateApiKeyParams {
    name: Some("Production web app (EU)".into()),
    ..Default::default()
  }
).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject apiKey = emailit.apiKeys().update("key_4KEaYMnfrxQGkuB0svwiuyt0ZhB",
  ApiKeyUpdateParams.builder()
    .setName("Production web app (EU)")
    .build()
);
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var apiKey = emailit.ApiKeys.Update("key_4KEaYMnfrxQGkuB0svwiuyt0ZhB", new ApiKeyUpdateOptions {
  Name = "Production web app (EU)",
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$apiKey = Emailit::apiKeys()->update('key_4KEaYMnfrxQGkuB0svwiuyt0ZhB', [
  'name' => 'Production web app (EU)',
]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/api-keys/key_4KEaYMnfrxQGkuB0svwiuyt0ZhB \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Production web app (EU)"
  }'
```

**200**

```json
{
  "object": "api_key",
  "id": "key_4KEaYMnfrxQGkuB0svwiuyt0ZhB",
  "name": "Production web app (EU)",
  "scope": "sending",
  "sending_domain_id": "dom_4K468YrjOkR1wwdhqiO0G9XEUey",
  "last_used_at": "2026-10-01T11:58:02.000000Z",
  "created_at": "2026-10-01T09:40:18.204917Z",
  "updated_at": "2026-10-01T12:10:33.000000Z"
}
```

**404**

```json
{
  "error": "API key not found"
}
```

**409**

```json
{
  "error": "Another API key with this name already exists"
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/api-keys/update/

## Regenerar una clave de API — POST /api-keys/{id}/regenerate

> Genera un secreto nuevo para una clave de API existente. El secreto anterior deja de funcionar al instante; el ID, el nombre, el permiso y el dominio no cambian.

# Regenerar una clave de API

Sustituye el secreto de la clave por uno nuevo. El secreto anterior deja de funcionar de inmediato para las peticiones a la API y los nuevos inicios de sesión SMTP. La clave conserva su ID, su nombre, su permiso y su dominio de envío, y `last_used_at` se restablece. Requiere una clave de API con el permiso `full`.

El secreto nuevo solo se devuelve en esta respuesta. Guárdalo enseguida y después actualiza todas las aplicaciones y los clientes SMTP que usaban el anterior. Si regeneras la clave con la que haces esta petición, usa el secreto nuevo en las peticiones siguientes.

`POST /api-keys/{id}/regenerate`

## Parámetros de ruta

- `id` (string, obligatorio): El ID de la clave de API (`key_…`) o el nombre de la clave.

## Devuelve

Devuelve el objeto de clave de API con el secreto nuevo en `key`.

- `key` (string): El secreto nuevo: `secret_` seguido de 32 letras y dígitos. Solo se muestra una vez.

- `scope` (string): `full` o `sending`.

- `sending_domain_id` (string | null): El dominio de envío al que está limitada una clave `sending`, o `null`.

- `last_used_at` (null): Siempre `null` después de una regeneración.

Devuelve `404` si ninguna clave de API activa coincide con `id`.

**Petición** `POST /api-keys/{id}/regenerate`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/api-keys/key_3t4p05pmtgBssZzXRT0QmJn3UgH/regenerate \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/api-keys/key_3t4p05pmtgBssZzXRT0QmJn3UgH/regenerate', {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { key } = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/api-keys/key_3t4p05pmtgBssZzXRT0QmJn3UgH/regenerate",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
new_secret = r.json()["key"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('api-keys/key_3t4p05pmtgBssZzXRT0QmJn3UgH/regenerate', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$newSecret = json_decode($response->getBody(), true)['key'];
```

**200**

```json
{
  "object": "api_key",
  "id": "key_3t4p05pmtgBssZzXRT0QmJn3UgH",
  "name": "Production server",
  "key": "secret_tbgPKVFk7QMi1nneTKdFcUWTyh8XoPz3",
  "scope": "sending",
  "sending_domain_id": "dom_3bTLTaNUAcCiXuokxifeIYdFOYf",
  "last_used_at": null,
  "created_at": "2026-09-12 08:01:44.120931+00",
  "updated_at": "2026-10-01T13:15:07.402881Z"
}
```

**404**

```json
{
  "error": "API key not found"
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/api-keys/regenerate/

## Eliminar una clave de API — DELETE /api-keys/{id}

> Revoca una clave de API para que deje de funcionar de inmediato en las peticiones a la API y por SMTP. La eliminación no se puede deshacer.

# Eliminar una clave de API

Revoca una clave de API. A partir de ese momento, las peticiones y los inicios de sesión SMTP con su secreto fallan.

`DELETE /api-keys/{id}`

Requiere una clave de API `full`. Puedes eliminar la clave con la que haces la llamada, así que asegúrate antes de que tu integración tenga otra clave. Una clave eliminada deja de aparecer en [Listar claves de API](/es/docs/api-reference/api-keys/list/), y su nombre queda libre para una clave nueva. Los emails ya enviados con la clave no se ven afectados.

## Parámetros de ruta

- `id` (string, obligatorio): El ID o el nombre de la clave de API.

## Devuelve

- `object` (string): Siempre `api_key`.

- `id` (string): El ID de la clave eliminada.

- `name` (string): El nombre de la clave.

- `deleted` (boolean): Siempre `true`.

**Petición** `DELETE /api-keys/{id}`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

await emailit.apiKeys.delete('key_4Kw6E8FodRivXbJlwPdn79gOxi1');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

client.api_keys.delete("key_4Kw6E8FodRivXbJlwPdn79gOxi1")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$emailit->apiKeys()->delete('key_4Kw6E8FodRivXbJlwPdn79gOxi1');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

client.api_keys.delete("key_4Kw6E8FodRivXbJlwPdn79gOxi1")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

err := client.ApiKeys.Delete("key_4Kw6E8FodRivXbJlwPdn79gOxi1")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

emailit.api_keys.delete("key_4Kw6E8FodRivXbJlwPdn79gOxi1").await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

emailit.apiKeys().delete("key_4Kw6E8FodRivXbJlwPdn79gOxi1");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

emailit.ApiKeys.Delete("key_4Kw6E8FodRivXbJlwPdn79gOxi1");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

Emailit::apiKeys()->delete('key_4Kw6E8FodRivXbJlwPdn79gOxi1');
```

**cURL**

```bash
curl -X DELETE https://api.emailit.com/v2/api-keys/key_4Kw6E8FodRivXbJlwPdn79gOxi1 \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "api_key",
  "id": "key_4Kw6E8FodRivXbJlwPdn79gOxi1",
  "name": "Back office",
  "deleted": true
}
```

**404**

```json
{
  "error": "API key not found"
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/api-keys/delete/