# Envoyer votre premier e-mail avec l’API

> Vérifiez un domaine, créez une clé API et envoyez votre premier e-mail avec cURL ou un SDK officiel pour Node.js, Python, PHP, Ruby, Go, Java, .NET ou Rust.

Ce démarrage rapide vous mène d’un nouveau compte à un e-mail livré en cinq minutes environ, plus le temps nécessaire à votre fournisseur DNS pour publier les enregistrements. Vous allez vérifier un domaine, créer une clé API, envoyer un e-mail et le retrouver dans le tableau de bord.

## Avant de commencer

- Un compte Emailit. Créez-le sur [dash.emailit.com](https://dash.emailit.com).
- Un domaine auquel vous pouvez ajouter des enregistrements DNS, comme `acme.com`. Vous pouvez aussi utiliser un sous-domaine, comme `mail.acme.com`.

## Ajouter et vérifier votre domaine

Emailit n’envoie que depuis des domaines que vous avez vérifiés, afin que les serveurs de messagerie des destinataires puissent contrôler que l’e-mail vient bien de vous.

1. **Ajoutez le domaine.** Accédez à **Email API → Domains**, sélectionnez **Add domain**, saisissez `acme.com` et sélectionnez **Create**.

2. **Publiez les enregistrements DNS.** La page du domaine liste les enregistrements à ajouter chez votre fournisseur DNS. Copiez les valeurs exactes depuis cette page. Les trois enregistrements obligatoires ressemblent à ceci :

   | Type | Nom | Valeur |
   | --- | --- | --- |
   | TXT | `emailit._domainkey.acme.com` | `v=DKIM1; t=s; h=sha256; p=…` (votre clé) |
   | TXT | `emailit.acme.com` | `v=spf1 include:_spf.emailit.com ~all` |
   | MX | `emailit.acme.com`, priorité 10 | `feedback-smtp.ffdc-1.emailit.com` |

   Si votre DNS est hébergé chez Cloudflare, vous pouvez plutôt publier les enregistrements en un clic. Consultez [Cloudflare](/fr/docs/domains/cloudflare/).

3. **Vérifiez le DNS.** Sélectionnez **Check DNS**. Quand SPF, DKIM et Return Path affichent **OK**, le domaine est **Verified**. La plupart des fournisseurs publient les enregistrements en quelques minutes, mais cela peut prendre jusqu’à 48 heures.

Sur Pay as you go, un domaine enregistré il y a moins de 30 jours affiche **Pending verification** jusqu’à ce que l’équipe Emailit l’examine. Pour les détails et les enregistrements facultatifs pour DMARC, le suivi et les e-mails entrants, consultez [Ajouter un domaine d’envoi](/fr/docs/domains/add-a-domain/).

## Créer une clé API

1. **Ouvrez la page API Keys.** Accédez à **Email API → API Keys** et sélectionnez **Add API key**.

2. **Nommez la clé et choisissez une portée.** Saisissez un nom comme `Quickstart`. **Sending Only** ne peut qu’envoyer des e-mails. **Full Access** peut aussi appeler le reste de l’API. Les deux conviennent pour ce démarrage rapide.

3. **Copiez la clé.** Sélectionnez **Create** et copiez la clé. Elle commence par `secret_` et n’est affichée qu’une seule fois.

4. **Stockez-la dans une variable d’environnement** pour la garder hors de votre code :

```bash
export EMAILIT_API_KEY="secret_••••"
```

## Envoyer un e-mail

Installez le SDK de votre langage, ou utilisez cURL :

**cURL**

```bash
# cURL is preinstalled on macOS, Linux and Windows 10 or later
curl --version
```

**Node.js**

```bash
npm install @emailit/node
```

**Python**

```bash
pip install emailit
```

**PHP**

```bash
composer require emailit/emailit-php
```

**Laravel**

```bash
composer require emailit/emailit-laravel
# Then add EMAILIT_API_KEY=secret_•••• to your .env file
```

**Ruby**

```bash
gem install emailit
```

**Go**

```bash
go get github.com/emailit/emailit-go/v2
```

**Java**

```xml
<dependency>
  <groupId>com.emailit</groupId>
  <artifactId>emailit-java</artifactId>
  <version><!-- latest version from Maven Central --></version>
</dependency>
```

**.NET**

```bash
dotnet add package Emailit
```

**Rust**

```bash
cargo add emailit
cargo add tokio --features full
```

Envoyez ensuite un e-mail. Utilisez une adresse d’expéditeur sur le domaine que vous avez vérifié, et envoyez-le à l’adresse e-mail avec laquelle vous avez créé votre compte :

**cURL**

```bash
curl https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "Acme <hello@acme.com>",
    "to": "ada@example.com",
    "subject": "Hello from Emailit",
    "html": "<p>This is my first email sent with Emailit.</p>"
  }'
```

**Node.js**

```javascript
import { Emailit } from '@emailit/node';

const emailit = new Emailit(process.env.EMAILIT_API_KEY);

const email = await emailit.emails.send({
  from: 'Acme <hello@acme.com>',
  to: 'ada@example.com',
  subject: 'Hello from Emailit',
  html: '<p>This is my first email sent with Emailit.</p>',
});

console.log(email.id, email.status);
```

**Python**

```python
import os
from emailit import EmailitClient

client = EmailitClient(os.environ["EMAILIT_API_KEY"])

email = client.emails.send({
    "from": "Acme <hello@acme.com>",
    "to": "ada@example.com",
    "subject": "Hello from Emailit",
    "html": "<p>This is my first email sent with Emailit.</p>",
})

print(email.id, email.status)
```

**PHP**

```php
<?php
require 'vendor/autoload.php';

$emailit = Emailit::client(getenv('EMAILIT_API_KEY'));

$email = $emailit->emails()->send([
    'from' => 'Acme <hello@acme.com>',
    'to' => 'ada@example.com',
    'subject' => 'Hello from Emailit',
    'html' => '<p>This is my first email sent with Emailit.</p>',
]);

echo $email->id . ' ' . $email->status;
```

**Laravel**

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

$email = Emailit::emails()->send([
    'from' => 'Acme <hello@acme.com>',
    'to' => 'ada@example.com',
    'subject' => 'Hello from Emailit',
    'html' => '<p>This is my first email sent with Emailit.</p>',
]);

logger()->info('Sent email', ['id' => $email->id]);
```

**Ruby**

```ruby
require "emailit"

client = Emailit::EmailitClient.new(ENV["EMAILIT_API_KEY"])

email = client.emails.send(
  from: "Acme <hello@acme.com>",
  to: "ada@example.com",
  subject: "Hello from Emailit",
  html: "<p>This is my first email sent with Emailit.</p>"
)

puts email.id, email.status
```

**Go**

```go
package main

import (
    "fmt"
    "os"

    "github.com/emailit/emailit-go/v2"
)

func main() {
    client := emailit.NewClient(os.Getenv("EMAILIT_API_KEY"))

    email, err := client.Emails.Send(&emailit.SendEmailRequest{
        From:    "Acme <hello@acme.com>",
        To:      []string{"ada@example.com"},
        Subject: "Hello from Emailit",
        Html:    "<p>This is my first email sent with Emailit.</p>",
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(email.Id)
}
```

**Java**

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

public class SendEmail {
    public static void main(String[] args) throws Exception {
        EmailitClient emailit = new EmailitClient(System.getenv("EMAILIT_API_KEY"));

        EmailitObject email = emailit.emails().send(
            EmailSendParams.builder()
                .setFrom("Acme <hello@acme.com>")
                .setTo(List.of("ada@example.com"))
                .setSubject("Hello from Emailit")
                .setHtml("<p>This is my first email sent with Emailit.</p>")
                .build()
        );

        System.out.println(email.getString("id"));
    }
}
```

**.NET**

```csharp
using Emailit;
using Emailit.Options;
using Emailit.Resources;

var emailit = new EmailitClient(Environment.GetEnvironmentVariable("EMAILIT_API_KEY"));

Email email = emailit.Emails.Send(new EmailSendOptions
{
    From = "Acme <hello@acme.com>",
    To = new[] { "ada@example.com" },
    Subject = "Hello from Emailit",
    Html = "<p>This is my first email sent with Emailit.</p>",
});

Console.WriteLine($"{email.Id} {email.Status}");
```

**Rust**

```rust
use emailit::types::CreateEmailBaseOptions;
use emailit::{Emailit, Result};

#[tokio::main]
async fn main() -> Result<()> {
    let api_key = std::env::var("EMAILIT_API_KEY").expect("EMAILIT_API_KEY is not set");
    let emailit = Emailit::new(&api_key);

    let email = CreateEmailBaseOptions::new(
        "Acme <hello@acme.com>",
        ["ada@example.com"],
        "Hello from Emailit",
    )
    .with_html("<p>This is my first email sent with Emailit.</p>");

    let result = emailit.emails.send(email).await?;
    println!("{:?}", result.id);

    Ok(())
}
```

> **Mode bac à sable:** Tant que votre espace de travail n’a pas l’accès production, vous ne pouvez envoyer qu’aux adresses e-mail des comptes des membres de l’espace de travail. Un envoi à toute autre personne renvoie `403` avec le code `unverified_workspace_recipient`. Quand vous êtes prêt à envoyer à de vrais destinataires, [demandez l’accès production](/fr/docs/workspaces/production-access/).

## Lire la réponse

Une requête réussie renvoie `200` avec le nouvel e-mail :

```json
{
  "object": "email",
  "id": "em_2pX7cN4kQ9vLm3RtB8yWd1Zs",
  "token": "2pX7cN4m8FqT1vKz6RbL3HwYd",
  "message_id": "<2pX7cN4m8FqT1vKz6RbL3HwYd@acme.com>",
  "from": "Acme <hello@acme.com>",
  "to": ["ada@example.com"],
  "subject": "Hello from Emailit",
  "status": "accepted",
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.418Z",
  "tracking": { "loads": false, "clicks": false }
}
```

| Champ | Signification |
| --- | --- |
| `id` | L’ID de l’e-mail. Utilisez-le pour consulter l’e-mail, l’annuler ou le relancer, et pour faire correspondre les événements webhook. |
| `status` | `accepted` signifie qu’Emailit a mis l’e-mail en file d’attente pour livraison. Il vaut `scheduled` si vous avez défini `scheduled_at`. |
| `message_id` | L’en-tête `Message-ID` de l’e-mail. |
| `ids` | Présent uniquement s’il y a plusieurs destinataires. Associe chaque adresse de destinataire à son propre ID d’e-mail. |
| `tracking` | Indique si les ouvertures (`loads`) et les clics sont suivis pour cet e-mail. Le suivi nécessite un [sous-domaine de suivi](/fr/docs/tracking/) vérifié. |

`accepted` ne signifie pas encore livré. La livraison se fait en arrière-plan, et le statut change au fil de sa progression.

## Vérifier dans le tableau de bord

Accédez à **Email API → Emails**. Votre e-mail se trouve en haut de l’onglet **Outgoing**. En quelques secondes, son statut passe généralement de **accepted** à **delivered**. Ouvrez-le pour voir les en-têtes, le contenu, chaque tentative de livraison avec la réponse du serveur destinataire, et les résultats des contrôles anti-spam.

La requête elle-même apparaît dans **Email API → Logs**, avec le code de statut et les corps de la requête et de la réponse.

## Dépannage

| Réponse | Cause | Solution |
| --- | --- | --- |
| `401` `API key required` ou `Invalid API key` | L’en-tête `Authorization` est absent ou la clé est incorrecte | Envoyez `Authorization: Bearer secret_…` avec une clé valide |
| `403` `unverified_workspace_recipient` | L’espace de travail est en mode bac à sable | Envoyez à l’adresse e-mail du compte d’un membre de l’espace de travail, ou [demandez l’accès production](/fr/docs/kb/403-unverified-workspace-recipient/) |
| `422` `From/Sender domain is not valid or not verified` | Le domaine d’expéditeur n’est pas vérifié dans cet espace de travail | Vérifiez le domaine, ou utilisez une adresse sur un domaine vérifié |
| `403` `Domain not authorized` | La clé Sending Only est limitée à un autre domaine | Utilisez une clé pour ce domaine, ou une clé sans restriction |
| `402` `Insufficient credits` | L’espace de travail n’a pas assez de crédits | [Ajoutez des crédits](/fr/docs/kb/402-insufficient-credits/) |
| `429` `Rate limit exceeded` | Trop d’e-mails dans la seconde ou dans la journée | Attendez la durée indiquée dans `retry-after`. Voir [Limites de débit](/fr/docs/kb/429-rate-limit-exceeded/). |

## Étapes suivantes

  - [Configurer des webhooks](/fr/docs/webhooks/set-up/): Recevez les événements de livraison, de rebond et d’ouverture en temps réel.
  - [Envoyer avec un modèle](/fr/docs/templates/): Concevez-le une fois dans le tableau de bord et envoyez-le par alias avec des variables.
  - [Idempotence](/fr/docs/email-api/idempotency/): Relancez les requêtes sans risque, sans envoyer deux fois.
  - [Liste de contrôle avant la mise en production](/fr/docs/get-started/go-live/): Ce qu’il faut vérifier avant d’envoyer à de vrais destinataires.

---
Source: https://emailit.com/fr/docs/quickstart/api/
