# Clés API API

> Créez, listez, renommez et révoquez les clés API d’un espace de travail.

URL de base : `https://api.emailit.com/v2`. Authentifiez-vous avec `Authorization: Bearer <API key>`.

## Créer une clé API — POST /api-keys

> Créez une clé API full ou sending pour l’espace de travail, éventuellement limitée à un domaine d’envoi. Le secret n’est renvoyé qu’une seule fois.

# Créer une clé API

Crée une clé API et renvoie son secret.

`POST /api-keys`

Nécessite une clé API `full`. Le secret contenu dans `key` n’est renvoyé que dans cette réponse et lorsque vous [régénérez](/fr/docs/api-reference/api-keys/regenerate/) la clé : stockez-le immédiatement en lieu sûr. La clé sert aussi de mot de passe SMTP. Pour savoir ce que permet chaque portée, consultez [Authentification](/fr/docs/api-reference/authentication/).

## Paramètres du corps

- `name` (string, obligatoire): Un nom qui indique où la clé est utilisée, comme `Production web app`. Doit être unique parmi les clés de l’espace de travail.

- `scope` (string): `full` pour accéder à tous les endpoints, ou `sending` pour les seuls endpoints d’envoi. Ne peut pas être modifiée par la suite.

- `sending_domain_id` (string): L’ID d’un domaine d’envoi (`dom_…`) auquel restreindre une clé `sending`. La clé ne peut alors envoyer que depuis des adresses de ce domaine. Ignoré pour les clés `full`.

## Réponse

Renvoie `201` avec l’[objet clé API](/fr/docs/api-reference/api-keys/get/) et son secret :

- `key` (string): Le secret, qui commence par `secret_`. Utilisez-le comme jeton bearer. Il n’est plus jamais affiché.

**Requête** `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"
  }
}
```

---
Source: https://emailit.com/fr/docs/api-reference/api-keys/create/

## Récupérer une clé API — GET /api-keys/{id}

> Récupérez une clé API par son ID ou son nom, avec sa portée, sa restriction de domaine et sa dernière utilisation. Le secret lui-même n’est jamais renvoyé.

# Récupérer une clé API

Récupère les détails d’une clé API. Le secret n’est pas inclus.

`GET /api-keys/{id}`

Nécessite une clé API `full`. Les clés supprimées sont introuvables.

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de la clé API (`key_…`) ou son nom. Encodez pour l’URL les noms qui contiennent des espaces.

## Réponse

Renvoie l’objet clé API.

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

- `id` (string): L’ID de la clé API.

- `name` (string): Le nom de la clé.

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

- `sending_domain_id` (string | null): L’ID du domaine d’envoi auquel la clé est restreinte, ou `null`.

- `last_used_at` (string | null): Date à laquelle la clé a authentifié une requête pour la dernière fois, ou `null` si elle n’a pas été utilisée depuis sa création ou sa régénération.

- `created_at` (string): Date de création de la clé.

- `updated_at` (string): Date à laquelle la clé a été renommée ou régénérée pour la dernière fois.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/api-keys/get/

## Lister les clés API — GET /api-keys

> Listez les clés API d’un espace de travail avec leur portée, leur restriction de domaine et leur dernière utilisation, de la plus récente à la plus ancienne. Les secrets ne sont jamais inclus.

# Lister les clés API

Renvoie une page des clés API de l’espace de travail, de la plus récente à la plus ancienne.

`GET /api-keys`

Nécessite une clé API `full`. Les clés supprimées et les secrets ne sont pas inclus. Consultez `last_used_at` pour repérer les clés que vous n’utilisez plus.

## Paramètres de requête

- `page` (integer): La page à renvoyer.

- `limit` (integer): Nombre de clés par page, de 1 à 100.

- `search` (string): Recherche insensible à la casse sur le nom de la clé.

- `match` (string): `all` ou `or`. Mode de combinaison des filtres ci-dessous.

- `order` (string): Une clé de filtre à utiliser pour le tri.

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

## Filtres

Ajoutez des filtres sous la forme `key.condition=value`, par exemple `scope.exact=sending`. Consultez [Filtrage et tri](/fr/docs/api-reference/filtering/).

| Clé | Type | Remarques |
| --- | --- | --- |
| `name` | string | |
| `scope` | string | `full` ou `sending`. |
| `type` | string | Type d’identifiant. Les clés créées dans le tableau de bord ou via l’API sont de type `api`. |
| `created_at` | date | |

Chaque clé est aussi une clé de tri.

## Réponse

Renvoie un tableau `data` d’[objets clé API](/fr/docs/api-reference/api-keys/get/) avec `next_page_url` et `previous_page_url`. Consultez [Pagination](/fr/docs/api-reference/pagination/).

**Requête** `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
}
```

---
Source: https://emailit.com/fr/docs/api-reference/api-keys/list/

## Mettre à jour une clé API — POST /api-keys/{id}

> Renommez une clé API. Le secret, la portée et la restriction de domaine restent identiques ; pour les modifier, créez une nouvelle clé ou régénérez le secret.

# Mettre à jour une clé API

Renomme une clé API.

`POST /api-keys/{id}`

Nécessite une clé API `full`. Seul le nom peut être modifié. Pour changer la portée ou la restriction de domaine, [créez une nouvelle clé](/fr/docs/api-reference/api-keys/create/) et supprimez celle-ci. Pour remplacer le secret, [régénérez](/fr/docs/api-reference/api-keys/regenerate/) la clé.

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de la clé API ou son nom actuel.

## Paramètres du corps

- `name` (string, obligatoire): Le nouveau nom. Doit être unique parmi les clés de l’espace de travail.

## Réponse

Renvoie l’[objet clé API](/fr/docs/api-reference/api-keys/get/) mis à jour.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/api-keys/update/

## Régénérer une clé API — POST /api-keys/{id}/regenerate

> Générez un nouveau secret pour une clé API existante. L’ancien secret cesse aussitôt de fonctionner ; l’ID, le nom, la portée et le domaine restent identiques.

# Régénérer une clé API

Remplace le secret de la clé par un nouveau. L’ancien secret cesse immédiatement de fonctionner pour les requêtes API et les nouvelles connexions SMTP. La clé conserve son ID, son nom, sa portée et son domaine d’envoi, et `last_used_at` est réinitialisé. Nécessite une clé API de portée `full`.

Le nouveau secret n’est renvoyé que dans cette réponse. Enregistrez-le immédiatement, puis mettez à jour chaque application et chaque client SMTP qui utilisait l’ancien. Si vous régénérez la clé qui effectue cette requête, utilisez le nouveau secret pour les requêtes suivantes.

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

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de la clé API (`key_…`) ou le nom de la clé.

## Réponse

Renvoie l’objet clé API avec le nouveau secret dans `key`.

- `key` (string): Le nouveau secret : `secret_` suivi de 32 lettres et chiffres. Affiché une seule fois.

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

- `sending_domain_id` (string | null): Le domaine d’envoi auquel une clé `sending` est limitée, ou `null`.

- `last_used_at` (null): Toujours `null` après une régénération.

Renvoie `404` si aucune clé API active ne correspond à `id`.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/api-keys/regenerate/

## Supprimer une clé API — DELETE /api-keys/{id}

> Révoquez une clé API pour qu’elle cesse immédiatement de fonctionner pour les requêtes API et SMTP. La suppression est irréversible.

# Supprimer une clé API

Révoque une clé API. Les requêtes et les connexions SMTP qui utilisent son secret échouent dès lors.

`DELETE /api-keys/{id}`

Nécessite une clé API `full`. Vous pouvez supprimer la clé avec laquelle vous effectuez l’appel : assurez-vous d’abord que votre intégration dispose d’une autre clé. Une clé supprimée n’apparaît plus dans [Lister les clés API](/fr/docs/api-reference/api-keys/list/), et son nom redevient disponible pour une nouvelle clé. Les e-mails déjà envoyés avec la clé ne sont pas affectés.

## Paramètres de chemin

- `id` (string, obligatoire): L’ID de la clé API ou son nom.

## Réponse

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

- `id` (string): L’ID de la clé supprimée.

- `name` (string): Le nom de la clé.

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

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/api-keys/delete/