# Chiavi API API

> Crea, elenca, rinomina e revoca le chiavi API di un workspace.

URL di base: `https://api.emailit.com/v2`. Autenticati con `Authorization: Bearer <API key>`.

## Crea una chiave API — POST /api-keys

> Crea una chiave API con permesso full o sending per il workspace, facoltativamente limitata a un dominio di invio. Il secret viene restituito una sola volta.

# Crea una chiave API

Crea una chiave API e ne restituisce il secret.

`POST /api-keys`

Richiede una chiave API `full`. Il secret in `key` viene restituito solo in questa risposta e quando [rigeneri](/it/docs/api-reference/api-keys/regenerate/) la chiave, quindi salvalo subito in un luogo sicuro. La chiave funziona anche come password SMTP. Per cosa consente ciascun permesso, vedi [Autenticazione](/it/docs/api-reference/authentication/).

## Parametri del corpo

- `name` (string, obbligatorio): Un nome che ti dice dove viene usata la chiave, ad esempio `Production web app`. Deve essere univoco tra le chiavi del workspace.

- `scope` (string): `full` per l’accesso a tutti gli endpoint, oppure `sending` solo per gli endpoint di invio. Non si può cambiare in seguito.

- `sending_domain_id` (string): L’ID di un dominio di invio (`dom_…`) a cui limitare una chiave `sending`. La chiave potrà quindi inviare solo da indirizzi di quel dominio. Viene ignorato per le chiavi `full`.

## Restituisce

Restituisce `201` con l’[oggetto chiave API](/it/docs/api-reference/api-keys/get/) e il suo secret:

- `key` (string): Il secret, che inizia con `secret_`. Usalo come token Bearer. Non viene più mostrato.

**Richiesta** `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"
  }
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/api-keys/create/

## Recupera una chiave API — GET /api-keys/{id}

> Recupera una chiave API per ID o per nome, con il permesso, la limitazione a un dominio e la data dell’ultimo utilizzo. Il secret non viene mai restituito.

# Recupera una chiave API

Recupera i dettagli di una chiave API. Il secret non è incluso.

`GET /api-keys/{id}`

Richiede una chiave API `full`. Le chiavi eliminate non vengono trovate.

## Parametri di percorso

- `id` (string, obbligatorio): L’ID della chiave API (`key_…`) o il suo nome. Codifica nell’URL i nomi che contengono spazi.

## Restituisce

Restituisce l’oggetto chiave API.

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

- `id` (string): L’ID della chiave API.

- `name` (string): Il nome della chiave.

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

- `sending_domain_id` (string | null): L’ID del dominio di invio a cui è limitata la chiave, oppure `null`.

- `last_used_at` (string | null): Quando la chiave ha autenticato l’ultima richiesta, oppure `null` se non è stata usata da quando è stata creata o rigenerata.

- `created_at` (string): Quando è stata creata la chiave.

- `updated_at` (string): Quando la chiave è stata rinominata o rigenerata l’ultima volta.

**Richiesta** `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"
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/api-keys/get/

## Elenca le chiavi API — GET /api-keys

> Elenca le chiavi API di un workspace con il permesso, la limitazione a un dominio e l’ultimo utilizzo, a partire dalla più recente. I secret non sono mai inclusi.

# Elenca le chiavi API

Restituisce una pagina delle chiavi API del workspace, a partire dalla più recente.

`GET /api-keys`

Richiede una chiave API `full`. Le chiavi eliminate e i secret non sono inclusi. Controlla `last_used_at` per trovare le chiavi che non usi più.

## Parametri di query

- `page` (integer): La pagina da restituire.

- `limit` (integer): Chiavi per pagina, da 1 a 100.

- `search` (string): Corrispondenza sul nome della chiave, senza distinzione tra maiuscole e minuscole.

- `match` (string): `all` o `or`. Come si combinano i filtri qui sotto.

- `order` (string): Una chiave di filtro per cui ordinare.

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

## Filtri

Aggiungi i filtri nella forma `key.condition=value`, ad esempio `scope.exact=sending`. Vedi [Filtri e ordinamento](/it/docs/api-reference/filtering/).

| Chiave | Tipo | Note |
| --- | --- | --- |
| `name` | string | |
| `scope` | string | `full` o `sending`. |
| `type` | string | Tipo di credenziale. Le chiavi create nel pannello o con l’API sono `api`. |
| `created_at` | date | |

Ogni chiave di filtro è anche una chiave di ordinamento.

## Restituisce

Restituisce un array `data` di [oggetti chiave API](/it/docs/api-reference/api-keys/get/) con `next_page_url` e `previous_page_url`. Vedi [Paginazione](/it/docs/api-reference/pagination/).

**Richiesta** `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
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/api-keys/list/

## Aggiorna una chiave API — POST /api-keys/{id}

> Rinomina una chiave API. Secret, permesso e limitazione a un dominio restano invariati; per cambiarli, crea una nuova chiave o rigenera il secret.

# Aggiorna una chiave API

Rinomina una chiave API.

`POST /api-keys/{id}`

Richiede una chiave API `full`. Si può cambiare solo il nome. Per cambiare il permesso o la limitazione a un dominio, [crea una nuova chiave](/it/docs/api-reference/api-keys/create/) ed elimina questa. Per sostituire il secret, [rigenera](/it/docs/api-reference/api-keys/regenerate/) la chiave.

## Parametri di percorso

- `id` (string, obbligatorio): L’ID della chiave API o il suo nome attuale.

## Parametri del corpo

- `name` (string, obbligatorio): Il nuovo nome. Deve essere univoco tra le chiavi del workspace.

## Restituisce

Restituisce l’[oggetto chiave API](/it/docs/api-reference/api-keys/get/) aggiornato.

**Richiesta** `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"
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/api-keys/update/

## Rigenera una chiave API — POST /api-keys/{id}/regenerate

> Emetti un nuovo secret per una chiave API esistente. Il vecchio secret smette subito di funzionare; ID, nome, permesso e dominio restano invariati.

# Rigenera una chiave API

Sostituisce il secret della chiave con uno nuovo. Il secret precedente smette subito di funzionare per le richieste API e per i nuovi accessi SMTP. La chiave mantiene ID, nome, permesso e dominio di invio, e `last_used_at` viene azzerato. Richiede una chiave API con il permesso `full`.

Il nuovo secret viene restituito solo in questa risposta. Salvalo subito, poi aggiorna ogni app e client SMTP che usava quello vecchio. Se rigeneri la chiave con cui fai questa richiesta, usa il nuovo secret per le richieste successive.

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

## Parametri di percorso

- `id` (string, obbligatorio): L’ID della chiave API (`key_…`) o il nome della chiave.

## Restituisce

Restituisce l’oggetto chiave API con il nuovo secret in `key`.

- `key` (string): Il nuovo secret, `secret_` seguito da 32 lettere e cifre. Viene mostrato una sola volta.

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

- `sending_domain_id` (string | null): Il dominio di invio a cui è limitata una chiave `sending`, oppure `null`.

- `last_used_at` (null): Sempre `null` dopo una rigenerazione.

Restituisce `404` se nessuna chiave API attiva corrisponde a `id`.

**Richiesta** `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"
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/api-keys/regenerate/

## Elimina una chiave API — DELETE /api-keys/{id}

> Revoca una chiave API perché smetta subito di funzionare per le richieste API e SMTP. L’eliminazione non si può annullare.

# Elimina una chiave API

Revoca una chiave API. Da questo momento le richieste e gli accessi SMTP con il suo secret non riescono.

`DELETE /api-keys/{id}`

Richiede una chiave API `full`. Puoi eliminare anche la chiave con cui stai chiamando, quindi assicurati prima che la tua integrazione abbia un’altra chiave. Una chiave eliminata non compare più in [Elenca le chiavi API](/it/docs/api-reference/api-keys/list/) e il suo nome torna disponibile per una nuova chiave. Le email già inviate con la chiave non ne risentono.

## Parametri di percorso

- `id` (string, obbligatorio): L’ID della chiave API o il suo nome.

## Restituisce

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

- `id` (string): L’ID della chiave eliminata.

- `name` (string): Il nome della chiave.

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

**Richiesta** `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"
}
```

---
Fonte: https://emailit.com/it/docs/api-reference/api-keys/delete/