# SDK et bibliothèques

> Les bibliothèques officielles d’Emailit pour Node.js, PHP, Laravel, Python, Ruby, Go, Java, .NET et Rust, le paquet MCP et la façon d’appeler l’API en HTTP simple.

Emailit maintient des bibliothèques clientes open source pour neuf langages et frameworks. Chacune encapsule l’API REST avec des erreurs typées et les mêmes noms de ressources que dans la [référence de l’API](/fr/docs/api-reference/). Si votre langage n’y figure pas, n’importe quel client HTTP fonctionne.

## Bibliothèques officielles

Toutes les bibliothèques sont sous licence MIT et publiées depuis [github.com/emailit](https://github.com/emailit).

| Langage | Paquet | Installation | Prérequis | Source |
| --- | --- | --- | --- | --- |
| Node.js | `@emailit/node` | `npm install @emailit/node` | Node.js 18+ | [emailit-node](https://github.com/emailit/emailit-node) |
| PHP | `emailit/emailit-php` | `composer require emailit/emailit-php` | PHP 8.1+ | [emailit-php](https://github.com/emailit/emailit-php) |
| Laravel | `emailit/emailit-laravel` | `composer require emailit/emailit-laravel` | Laravel 10, 11 ou 12 | [emailit-laravel](https://github.com/emailit/emailit-laravel) |
| Python | `emailit` | `pip install emailit` | Python 3.7+ | [emailit-python](https://github.com/emailit/emailit-python) |
| Ruby | `emailit` | `bundle add emailit` | Ruby 3.0+ | [emailit-ruby](https://github.com/emailit/emailit-ruby) |
| Go | `github.com/emailit/emailit-go/v2` | `go get github.com/emailit/emailit-go/v2` | Go 1.21+ | [emailit-go](https://github.com/emailit/emailit-go) |
| Java | `com.emailit:emailit-java` | Maven ou Gradle, voir ci-dessous | Java 11+ | [emailit-java](https://github.com/emailit/emailit-java) |
| .NET | `Emailit` | `dotnet add package Emailit` | .NET 8+ | [emailit-dotnet](https://github.com/emailit/emailit-dotnet) |
| Rust | `emailit` | `cargo add emailit` | Rust 1.85+ et Tokio | [emailit-rust](https://github.com/emailit/emailit-rust) |

Pour Java, ajoutez la dépendance avec la dernière version indiquée dans le dépôt :

```xml title="pom.xml"
<dependency>
  <groupId>com.emailit</groupId>
  <artifactId>emailit-java</artifactId>
  <version>VERSION</version>
</dependency>
```

```groovy title="build.gradle"
implementation 'com.emailit:emailit-java:VERSION'
```

## Envoyer un e-mail

Chaque bibliothèque prend votre clé API à la création du client. Chargez-la depuis une variable d’environnement plutôt que de l’écrire en dur dans le code.

**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: 'Welcome to Acme',
  html: '<p>Thanks for signing up.</p>',
});

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

**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' => 'Welcome to Acme',
    'html'    => '<p>Thanks for signing up.</p>',
]);

echo $email->id;
```

**Laravel**

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

$email = Emailit::emails()->send([
    'from'    => 'Acme <hello@acme.com>',
    'to'      => 'ada@example.com',
    'subject' => 'Welcome to Acme',
    'html'    => '<p>Thanks for signing up.</p>',
]);
```

**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": "Welcome to Acme",
    "html": "<p>Thanks for signing up.</p>",
})

print(email.id)
```

**Ruby**

```ruby
require "emailit"

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

email = client.emails.send(
  from: "Acme <hello@acme.com>",
  to: "ada@example.com",
  subject: "Welcome to Acme",
  html: "<p>Thanks for signing up.</p>"
)

puts email.id
```

**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: "Welcome to Acme",
        Html:    "<p>Thanks for signing up.</p>",
    })
    if err != nil {
        panic(err)
    }

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

**Java**

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

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("Welcome to Acme")
        .setHtml("<p>Thanks for signing up.</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 = "Welcome to Acme",
    Html = "<p>Thanks for signing up.</p>",
});

Console.WriteLine(email.Id);
```

**Rust**

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

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

    let options = CreateEmailBaseOptions::new(
        "Acme <hello@acme.com>",
        ["ada@example.com"],
        "Welcome to Acme",
    )
    .with_html("<p>Thanks for signing up.</p>");

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

    Ok(())
}
```

**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": "Welcome to Acme",
    "html": "<p>Thanks for signing up.</p>"
  }'
```

L’adresse `from` doit appartenir à un [domaine d’envoi vérifié](/fr/docs/domains/add-a-domain/). Tant que votre espace de travail n’a pas l’[accès production](/fr/docs/workspaces/production-access/), vous ne pouvez envoyer qu’aux adresses e-mail de compte des membres de l’espace de travail.

## Ce que couvrent les bibliothèques

Chaque bibliothèque expose les mêmes services : e-mails, domaines, clés API, listes de contacts, abonnés, modèles, adresses bloquées, vérifications d’e-mails, listes de vérification d’e-mails, webhooks, contacts et événements. Les erreurs sont levées sous forme d’exceptions typées ou renvoyées sous forme de valeurs d’erreur, par exemple une erreur d’authentification pour `401`, une erreur de limite de débit pour `429` et une erreur de validation pour `422` : vous pouvez ainsi traiter chaque cas séparément.

Certains endpoints plus récents ne sont pas encore couverts, notamment le transfert d’un e-mail, les campagnes, les automatisations, les formulaires et les rapports DMARC. Les bibliothèques ne définissent pas non plus l’en-tête `Idempotency-Key`. Dans ces cas, appelez l’endpoint en HTTP avec la même clé API, comme ci-dessous.

Pour la configuration propre à chaque framework, y compris les transports d’e-mail, les routes de webhook et la configuration SMTP, consultez les guides des frameworks : [Node.js](/fr/docs/frameworks/nodejs/), [Next.js](/fr/docs/frameworks/nextjs/), [Nuxt](/fr/docs/frameworks/nuxt/), [Laravel](/fr/docs/frameworks/laravel/), [PHP](/fr/docs/frameworks/php/), [Python](/fr/docs/frameworks/python/), [Ruby on Rails](/fr/docs/frameworks/rails/), [Go](/fr/docs/frameworks/go/), [Java](/fr/docs/frameworks/java/), [.NET](/fr/docs/frameworks/dotnet/) et [WordPress](/fr/docs/frameworks/wordpress/).

## Paquet du serveur MCP

Le paquet open source [`@emailit/emailit-mcp`](https://github.com/emailit/emailit-mcp) exécute un serveur MCP sur votre machine pour que les assistants IA puissent appeler Emailit avec votre clé API :

```bash
npx -y @emailit/emailit-mcp
```

La plupart des utilisateurs n’en ont pas besoin : le serveur hébergé sur `https://api.emailit.com/mcp` ne nécessite aucune installation. Comparez les deux dans [Exécuter le serveur MCP en local](/fr/docs/mcp/local-server/).

`@emailit/js` est un autre paquet : c’est le script de navigateur qui affiche les [formulaires Emailit](/fr/docs/forms/install/) sur votre site, pas un client de l’API.

## Utiliser l’API en HTTP

Vous n’avez pas besoin d’une bibliothèque. N’importe quel client HTTP capable d’envoyer du JSON fonctionne :

- URL de base : `https://api.emailit.com/v2`
- En-têtes : `Authorization: Bearer <your API key>` et `Content-Type: application/json`
- Corps et réponses : JSON

Par exemple, pour transférer un e-mail avec une clé d’idempotence depuis Node.js sans le SDK :

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4K6oASS7KP9ztzWmSN9ndEu13HW/forward', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
    'Content-Type': 'application/json',
    'Idempotency-Key': 'forward-order-1042',
  },
  body: JSON.stringify({ to: 'support@acme.com' }),
});

if (!response.ok) {
  throw new Error(`Emailit returned ${response.status}: ${await response.text()}`);
}
```

Lisez [Erreurs](/fr/docs/api-reference/errors/) et [Limites de débit](/fr/docs/api-reference/rate-limits/) avant de développer votre propre client, afin de traiter correctement les réponses `4xx` et `retry-after`. Si votre application parle déjà SMTP, vous pouvez aussi vous passer complètement de l’API et utiliser le [relais SMTP](/fr/docs/smtp/settings/).

## Bibliothèques de la communauté

Emailit ne maintient pas d’autres bibliothèques que celles de la liste ci-dessus. Si vous en trouvez ou en développez une pour un autre langage ou framework, examinez son code avant de lui confier une clé API, et privilégiez une clé Sending Only limitée à un domaine. Écrivez-nous à support@emailit.com ou sur [Discord](https://discord.emailit.com) si vous souhaitez qu’elle soit mentionnée ici.

## Voir aussi

  - [Vue d’ensemble pour les développeurs](/fr/docs/developers/): URL de base, ID, erreurs, pagination et limites de débit.
  - [Clés API](/fr/docs/developers/api-keys/): Créez la clé dont votre bibliothèque a besoin.
  - [Envoyer des e-mails avec l’API](/fr/docs/email-api/send-email/): Modèles, pièces jointes, programmation et suivi.
  - [Signatures de webhook](/fr/docs/webhooks/request-signature/): Vérifiez que les requêtes de webhook proviennent d’Emailit.

---
Source: https://emailit.com/fr/docs/sdks/