# Erste E-Mail per API senden

> Verifizieren Sie eine Domain, erstellen Sie einen API-Schlüssel und senden Sie Ihre erste E-Mail mit cURL oder einem offiziellen SDK für Node.js, Python, PHP, Ruby, Go, Java, .NET oder Rust.

Dieser Schnellstart führt Sie in etwa fünf Minuten von einem neuen Konto zu einer zugestellten E-Mail, zuzüglich der Zeit, die Ihr DNS-Anbieter zum Veröffentlichen der Einträge braucht. Sie verifizieren eine Domain, erstellen einen API-Schlüssel, senden eine E-Mail und finden sie in der Weboberfläche.

## Voraussetzungen

- Ein Emailit-Konto. Registrieren Sie sich unter [dash.emailit.com](https://dash.emailit.com).
- Eine Domain, für die Sie DNS-Einträge anlegen können, etwa `acme.com`. Sie können auch eine Subdomain verwenden, etwa `mail.acme.com`.

## Domain hinzufügen und verifizieren

Emailit sendet nur von Domains, die Sie verifiziert haben, damit die Mailserver der Empfänger prüfen können, dass die E-Mail wirklich von Ihnen stammt.

1. **Domain hinzufügen.** Öffnen Sie **Email API → Domains**, wählen Sie **Add domain**, geben Sie `acme.com` ein und wählen Sie **Create**.

2. **DNS-Einträge anlegen.** Die Domainseite listet die Einträge auf, die Sie bei Ihrem DNS-Anbieter anlegen müssen. Kopieren Sie die exakten Werte von dieser Seite. Die drei erforderlichen Einträge sehen so aus:

   | Typ | Name | Wert |
   | --- | --- | --- |
   | TXT | `emailit._domainkey.acme.com` | `v=DKIM1; t=s; h=sha256; p=…` (Ihr Schlüssel) |
   | TXT | `emailit.acme.com` | `v=spf1 include:_spf.emailit.com ~all` |
   | MX | `emailit.acme.com`, Priorität 10 | `feedback-smtp.ffdc-1.emailit.com` |

   Wenn Ihr DNS bei Cloudflare liegt, können Sie die Einträge stattdessen mit einem Klick anlegen. Siehe [Cloudflare](/de/docs/domains/cloudflare/).

3. **DNS prüfen.** Wählen Sie **Check DNS**. Wenn SPF, DKIM und Return Path **OK** anzeigen, ist die Domain **Verified**. Die meisten Anbieter veröffentlichen Einträge innerhalb von Minuten, es kann aber bis zu 48 Stunden dauern.

Bei Pay as you go zeigt eine Domain, die vor weniger als 30 Tagen registriert wurde, **Pending verification**, bis das Emailit-Team sie geprüft hat. Details und optionale Einträge für DMARC, Tracking und eingehende E-Mails finden Sie unter [Versanddomain hinzufügen](/de/docs/domains/add-a-domain/).

## API-Schlüssel erstellen

1. **API Keys öffnen.** Öffnen Sie **Email API → API Keys** und wählen Sie **Add API key**.

2. **Schlüssel benennen und Scope wählen.** Geben Sie einen Namen wie `Quickstart` ein. **Sending Only** kann nur E-Mails senden. **Full Access** kann zusätzlich den Rest der API aufrufen. Für diesen Schnellstart funktioniert beides.

3. **Schlüssel kopieren.** Wählen Sie **Create** und kopieren Sie den Schlüssel. Er beginnt mit `secret_` und wird nur einmal angezeigt.

4. **Speichern Sie ihn in einer Umgebungsvariablen**, damit er nicht in Ihrem Code landet:

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

## E-Mail senden

Installieren Sie das SDK für Ihre Sprache oder verwenden Sie 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
```

Senden Sie dann eine E-Mail. Verwenden Sie eine Absenderadresse auf der verifizierten Domain und senden Sie an die E-Mail-Adresse, mit der Sie sich registriert haben:

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

> **Sandbox-Modus:** Solange Ihr Workspace keinen Produktionszugang hat, können Sie nur an die Konto-E-Mail-Adressen von Workspace-Mitgliedern senden. Das Senden an andere Adressen gibt `403` mit dem Code `unverified_workspace_recipient` zurück. Wenn Sie für echte Empfänger bereit sind, [beantragen Sie Produktionszugang](/de/docs/workspaces/production-access/).

## Antwort lesen

Eine erfolgreiche Anfrage gibt `200` mit der neuen E-Mail zurück:

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

| Feld | Bedeutung |
| --- | --- |
| `id` | Die ID der E-Mail. Damit rufen Sie die E-Mail ab, stornieren sie oder senden sie erneut und ordnen Webhook-Events zu. |
| `status` | `accepted` bedeutet, dass Emailit die E-Mail zur Zustellung in die Warteschlange gestellt hat. Wenn Sie `scheduled_at` gesetzt haben, ist er `scheduled`. |
| `message_id` | Der Header `Message-ID` der E-Mail. |
| `ids` | Nur bei mehreren Empfängern vorhanden. Ordnet jeder Empfängeradresse ihre eigene E-Mail-ID zu. |
| `tracking` | Ob Öffnungen (`loads`) und Klicks für diese E-Mail erfasst werden. Tracking erfordert eine verifizierte [Tracking-Subdomain](/de/docs/tracking/). |

`accepted` heißt noch nicht, dass die E-Mail zugestellt ist. Die Zustellung erfolgt im Hintergrund, und der Status ändert sich mit ihrem Fortschritt.

## In der Weboberfläche prüfen

Öffnen Sie **Email API → Emails**. Ihre E-Mail steht oben im Tab **Outgoing**. Innerhalb weniger Sekunden wechselt ihr Status meist von **accepted** zu **delivered**. Öffnen Sie sie, um die Header, den Inhalt, jeden Zustellversuch mit der Antwort des Empfangsservers und die Ergebnisse der Spam-Prüfung zu sehen.

Die Anfrage selbst erscheint unter **Email API → Logs**, mit dem Statuscode sowie dem Anfrage- und Antwort-Body.

## Fehlerbehebung

| Antwort | Ursache | Lösung |
| --- | --- | --- |
| `401` `API key required` oder `Invalid API key` | Der Header `Authorization` fehlt oder der Schlüssel ist falsch | Senden Sie `Authorization: Bearer secret_…` mit einem aktuellen Schlüssel |
| `403` `unverified_workspace_recipient` | Der Workspace ist im Sandbox-Modus | Senden Sie an die Konto-E-Mail-Adresse eines Workspace-Mitglieds oder [beantragen Sie Produktionszugang](/de/docs/kb/403-unverified-workspace-recipient/) |
| `422` `From/Sender domain is not valid or not verified` | Die Absenderdomain ist in diesem Workspace nicht verifiziert | Verifizieren Sie die Domain oder verwenden Sie eine Adresse auf einer verifizierten Domain |
| `403` `Domain not authorized` | Der reine Sende-Schlüssel ist auf eine andere Domain beschränkt | Verwenden Sie einen Schlüssel für diese Domain oder einen unbeschränkten Schlüssel |
| `402` `Insufficient credits` | Der Workspace hat nicht genug Credits | [Credits hinzufügen](/de/docs/kb/402-insufficient-credits/) |
| `429` `Rate limit exceeded` | Zu viele E-Mails in dieser Sekunde oder heute | Warten Sie die Zeit in `retry-after` ab. Siehe [Rate Limits](/de/docs/kb/429-rate-limit-exceeded/). |

## Nächste Schritte

  - [Webhooks einrichten](/de/docs/webhooks/set-up/): Events zu Zustellungen, Bounces und Öffnungen in Echtzeit erhalten.
  - [Mit einer Vorlage senden](/de/docs/templates/): Einmal in der Weboberfläche gestalten und per Alias mit Variablen senden.
  - [Idempotenz](/de/docs/email-api/idempotency/): Anfragen sicher wiederholen, ohne doppelt zu senden.
  - [Checkliste für den Livegang](/de/docs/get-started/go-live/): Was Sie prüfen sollten, bevor Sie an echte Empfänger senden.

---
Quelle: https://emailit.com/de/docs/quickstart/api/
