# SDKs und Bibliotheken

> Offizielle Emailit-Bibliotheken für Node.js, PHP, Laravel, Python, Ruby, Go, Java, .NET und Rust, dazu das MCP-Paket und wie Sie die API direkt per HTTP aufrufen.

Emailit pflegt Open-Source-Client-Bibliotheken für neun Sprachen und Frameworks. Jede kapselt die REST-API mit typisierten Fehlern und denselben Ressourcennamen wie in der [API-Referenz](/de/docs/api-reference/). Wenn Ihre Sprache nicht aufgeführt ist, funktioniert jeder HTTP-Client.

## Offizielle Bibliotheken

Alle Bibliotheken stehen unter der MIT-Lizenz und werden über [github.com/emailit](https://github.com/emailit) veröffentlicht.

| Sprache | Paket | Installation | Voraussetzung | Quellcode |
| --- | --- | --- | --- | --- |
| 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 oder 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 oder Gradle, siehe unten | 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+ und Tokio | [emailit-rust](https://github.com/emailit/emailit-rust) |

Fügen Sie für Java die Abhängigkeit mit der neuesten Version aus dem Repository hinzu:

```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'
```

## E-Mail senden

Jede Bibliothek erhält Ihren API-Schlüssel, wenn Sie den Client erstellen. Laden Sie ihn aus einer Umgebungsvariable, statt ihn fest in den Code zu schreiben.

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

Die Adresse in `from` muss auf einer [verifizierten Versanddomain](/de/docs/domains/add-a-domain/) liegen. Bis Ihr Workspace [Produktionszugang](/de/docs/workspaces/production-access/) hat, können Sie nur an die Konto-E-Mail-Adressen der Mitglieder des Workspaces senden.

## Was die Bibliotheken abdecken

Jede Bibliothek bietet dieselben Services: E-Mails, Domains, API-Schlüssel, Kontaktlisten, Abonnenten, Vorlagen, Sperrungen, E-Mail-Verifizierungen, Verifizierungslisten, Webhooks, Kontakte und Events. Fehler werden als typisierte Exceptions oder Fehlerwerte ausgegeben, zum Beispiel ein Authentifizierungsfehler bei `401`, ein Rate-Limit-Fehler bei `429` und ein Validierungsfehler bei `422`, sodass Sie jeden Fall getrennt behandeln können.

Einige neuere Endpunkte sind noch nicht gekapselt, darunter das Weiterleiten einer E-Mail, Kampagnen, Automatisierungen, Formulare und DMARC-Berichte. Außerdem setzen die Bibliotheken den Header `Idempotency-Key` nicht. Rufen Sie diese Endpunkte per HTTP mit demselben API-Schlüssel auf, wie unten gezeigt.

Die Einrichtung für einzelne Frameworks, einschließlich Mail-Transports, Webhook-Routen und SMTP-Konfiguration, finden Sie in den Framework-Anleitungen: [Node.js](/de/docs/frameworks/nodejs/), [Next.js](/de/docs/frameworks/nextjs/), [Nuxt](/de/docs/frameworks/nuxt/), [Laravel](/de/docs/frameworks/laravel/), [PHP](/de/docs/frameworks/php/), [Python](/de/docs/frameworks/python/), [Ruby on Rails](/de/docs/frameworks/rails/), [Go](/de/docs/frameworks/go/), [Java](/de/docs/frameworks/java/), [.NET](/de/docs/frameworks/dotnet/) und [WordPress](/de/docs/frameworks/wordpress/).

## Paket für den MCP-Server

Das Open-Source-Paket [`@emailit/emailit-mcp`](https://github.com/emailit/emailit-mcp) führt einen MCP-Server auf Ihrem Rechner aus, damit KI-Assistenten Emailit mit Ihrem API-Schlüssel aufrufen können:

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

Die meisten brauchen es nicht: Der gehostete Server unter `https://api.emailit.com/mcp` erfordert keine Installation. Einen Vergleich der beiden finden Sie unter [MCP-Server lokal ausführen](/de/docs/mcp/local-server/).

`@emailit/js` ist ein anderes Paket: Es ist das Browser-Skript, das [Emailit-Formulare](/de/docs/forms/install/) auf Ihrer Website anzeigt, kein API-Client.

## API per HTTP nutzen

Sie brauchen keine Bibliothek. Jeder HTTP-Client, der JSON senden kann, funktioniert:

- Basis-URL: `https://api.emailit.com/v2`
- Header: `Authorization: Bearer <your API key>` und `Content-Type: application/json`
- Anfrage-Bodys und Antworten: JSON

So leiten Sie zum Beispiel eine E-Mail mit einem Idempotenzschlüssel aus Node.js ohne das SDK weiter:

```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()}`);
}
```

Lesen Sie [Fehler](/de/docs/api-reference/errors/) und [Rate Limits](/de/docs/api-reference/rate-limits/), bevor Sie Ihren eigenen Client entwickeln, damit Sie Antworten mit `4xx` und `retry-after` richtig behandeln. Wenn Ihre App bereits SMTP spricht, können Sie die API auch ganz weglassen und das [SMTP-Relay](/de/docs/smtp/settings/) verwenden.

## Bibliotheken aus der Community

Emailit pflegt keine Bibliotheken außer denen in der Liste oben. Wenn Sie eine für eine andere Sprache oder ein anderes Framework finden oder entwickeln, prüfen Sie ihren Code, bevor Sie ihr einen API-Schlüssel geben, und verwenden Sie möglichst einen Schlüssel mit Sending Only, der auf eine Domain beschränkt ist. Schreiben Sie uns an support@emailit.com oder auf [Discord](https://discord.emailit.com), wenn sie hier erwähnt werden soll.

## Siehe auch

  - [Entwicklerübersicht](/de/docs/developers/): Basis-URL, IDs, Fehler, Paginierung und Rate Limits.
  - [API-Schlüssel](/de/docs/developers/api-keys/): Den Schlüssel erstellen, den Ihre Bibliothek braucht.
  - [E-Mails per API senden](/de/docs/email-api/send-email/): Vorlagen, Anhänge, Planung und Tracking.
  - [Webhook-Signaturen](/de/docs/webhooks/request-signature/): Prüfen, ob Webhook-Anfragen von Emailit stammen.

---
Quelle: https://emailit.com/de/docs/sdks/