# Vérification d’e-mails API

> Vérifiez une adresse unique en temps réel.

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

## Vérifier une adresse — POST /email-verifications

> Vérifiez une adresse e-mail en temps réel : syntaxe, adresses jetables et génériques, enregistrements MX et, en mode complet, la boîte aux lettres elle-même.

# Vérifier une adresse

Vérifie une adresse e-mail et renvoie le résultat dans la réponse. Chaque vérification coûte 5 crédits, débités avant le contrôle. Pour vérifier de nombreuses adresses à la fois, [créez une liste de vérification](/fr/docs/api-reference/email-verifications/lists/create/). Nécessite une clé API avec la portée `full`.

`POST /email-verifications`

## Corps de la requête

- `email` (string, obligatoire): Adresse à vérifier. Une valeur qui n’est pas une adresse valide renvoie tout de même `200`, avec `result: "invalid"` et un score de `0`, et elle est facturée.

- `mode` (string): `fast` (par défaut) vérifie la syntaxe, les adresses jetables et génériques, les fournisseurs gratuits, le charabia, les enregistrements MX et l’âge du domaine. `full` se connecte en plus au serveur de messagerie du destinataire pour vérifier si la boîte aux lettres existe, si elle est désactivée ou pleine, et si le domaine accepte toutes les adresses. En mode `fast`, les contrôles de la boîte aux lettres valent `null`.

## Réponse

Renvoie `200 OK` avec un objet `email_verification`. Emailit envoie aussi l’événement webhook [`email_verification.created`](/fr/docs/webhooks/events/email-verification/created/).

| Statut | Cas |
| --- | --- |
| `400` | `email` est absent ou `mode` ne vaut ni `fast` ni `full` (erreur de validation standard). |
| `402` | Il reste moins de 5 crédits dans l’espace de travail. Le corps est `{"error": {"message": "…", "code": 402}}`. |

### Résultat

| `result` | Signification |
| --- | --- |
| `safe` | A réussi tous les contrôles avec un score d’au moins 70. |
| `invalid` | La syntaxe est invalide ou le domaine n’a pas d’enregistrement MX : l’adresse ne peut pas recevoir d’e-mails. |
| `disposable` | Le domaine appartient à un service d’adresses e-mail jetables. |
| `disabled` | La boîte aux lettres existe, mais elle est désactivée. Mode `full` uniquement. |
| `inbox_full` | La boîte aux lettres est pleine. Mode `full` uniquement. |
| `role` | Une adresse générique, comme `info@` ou `support@`. |
| `unknown` | Aucun contrôle n’a échoué, mais le score est inférieur à 70. |

### Score et risque

`score` va de `0` à `100`. `risk` vaut `high` si la syntaxe est invalide, si le domaine n’a pas d’enregistrement MX, si l’adresse est jetable ou si la boîte aux lettres est désactivée. Sinon, il suit le score : `low` à partir de 80, `medium` à partir de 50 et `high` en dessous de 50.

### Champs

- `status` (string): `completed` pour les vérifications unitaires.

- `checks` (object): Contrôles individuels : `valid_syntax`, `disposable`, `role_account`, `free_email`, `gibberish` et `has_mx_records` (booléens), `domain_age` (âge du domaine en jours, ou `null` s’il est inconnu), ainsi que les contrôles du mode `full` : `smtp_connect`, `deliverable`, `disabled`, `inbox_full` et `catch_all` (`null` en mode `fast`).

- `address` (object): L’adresse décomposée en `mailbox`, `domain`, `suffix` (la partie après `+`, ou `null`) et `root` (l’adresse sans le suffixe).

- `did_you_mean` (string | null): Correction suggérée pour une faute de frappe probable, par exemple `ada@gmail.com` pour `ada@gmial.com`.

- `mx_records` (object[]): Les enregistrements MX du domaine, chacun avec `priority` et `exchange`.

**Requête** `POST /email-verifications`

**Node.js**

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

const result = await emailit.emailVerifications.verify({ email: 'ada@example.com' });
```

**Python**

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

result = client.email_verifications.verify({"email": "ada@example.com"})
```

**PHP**

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

$result = $emailit->emailVerifications()->verify(['email' => 'ada@example.com']);
```

**Ruby**

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

result = client.email_verifications.verify(email: "ada@example.com")
```

**Go**

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

result, err := client.EmailVerifications.Verify(&emailit.VerifyEmailRequest{Email: "ada@example.com"})
```

**Rust**

```rust
use emailit::Emailit;
let emailit = Emailit::new("your_api_key");

let result = emailit.email_verifications.verify(emailit::types::VerifyEmailParams::new("ada@example.com")).await?;
```

**Java**

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

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject result = emailit.emailVerifications().create(EmailVerificationCreateParams.builder().setEmail("ada@example.com").build());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var result = emailit.EmailVerifications.Verify(new EmailVerificationVerifyOptions { Email = "ada@example.com" });
```

**Laravel**

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

$result = Emailit::emailVerifications()->verify(['email' => 'ada@example.com']);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/email-verifications \
  -H "Authorization: Bearer your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"email": "ada@example.com"}'
```

**200**

```json
{
  "id": "ev_2xLd4Wq8Bn1Ys6Pk3Rm9Tc0Fh5a",
  "object": "email_verification",
  "email": "ada@example.com",
  "status": "completed",
  "score": 100,
  "risk": "low",
  "result": "safe",
  "mode": "fast",
  "checks": {
    "valid_syntax": true,
    "disposable": false,
    "role_account": false,
    "inbox_full": null,
    "deliverable": null,
    "disabled": null,
    "catch_all": null,
    "free_email": false,
    "smtp_connect": null,
    "has_mx_records": true,
    "domain_age": 10957,
    "gibberish": false
  },
  "address": {
    "mailbox": "ada",
    "domain": "example.com",
    "suffix": null,
    "root": "ada@example.com"
  },
  "did_you_mean": null,
  "mx_records": [
    { "priority": 10, "exchange": "mx1.example.com" }
  ],
  "created_at": "2026-10-01T10:20:31.118000+00:00",
  "updated_at": "2026-10-01T10:20:31.118000+00:00"
}
```

**402**

```json
{
  "error": {
    "message": "Workspace has insufficient email credits for email verification. Each verification requires 5 credits.",
    "code": 402
  }
}
```

---
Source: https://emailit.com/fr/docs/api-reference/email-verifications/verify/