# E-Mails API

> E-Mails senden, Nachrichten und ihre Inhalte abrufen sowie E-Mails planen, stornieren, erneut senden oder weiterleiten.

Basis-URL: `https://api.emailit.com/v2`. Authentifizieren Sie sich mit `Authorization: Bearer <API key>`.

## E-Mail senden — POST /emails

> Eine E-Mail an einen oder mehrere Empfänger senden, mit HTML oder Text, Vorlage, Anhängen, eigenen Headern, Metadaten, Planung und Tracking.

# E-Mail senden

Sendet eine E-Mail von einer verifizierten Versanddomain. Jeder Empfänger erhält eine eigene Kopie mit eigener E-Mail-ID, und jeder Empfänger kostet einen Credit.

`POST /emails`

Funktioniert mit API-Schlüsseln mit dem Scope `sending` oder `full`. Sendungen zählen zu den [Versandlimits](/de/docs/api-reference/rate-limits/) des Workspaces, und eine erfolgreiche Antwort bedeutet, dass die E-Mail angenommen und in die Warteschlange gestellt wurde, nicht dass sie bereits zugestellt ist. Verfolgen Sie die Zustellung mit [Webhooks](/de/docs/webhooks/) oder [E-Mail abrufen](/de/docs/api-reference/emails/get/). Nicht verifizierte Workspaces können nur an die E-Mail-Adressen der Konten ihrer Mitglieder senden.

## Header

- `Idempotency-Key` (string): Ein eindeutiger Schlüssel aus bis zu 256 Buchstaben, Ziffern, `-` und `_`. Eine Wiederholung mit demselben Schlüssel innerhalb von 24 Stunden gibt die erste Antwort zurück, statt erneut zu senden. Siehe [Idempotenz](/de/docs/api-reference/idempotency/).

## Body-Parameter

- `from` (string, erforderlich): Der Absender, als `hello@acme.com` oder `Acme <hello@acme.com>`. Die Adresse muss auf einer verifizierten Versanddomain des Workspaces liegen und auf der Domain des Schlüssels, wenn der Schlüssel [auf eine Domain beschränkt](/de/docs/api-reference/authentication/#restrict-a-key-to-one-domain) ist.

- `to` (string | string[], erforderlich): Empfänger, als Array oder als kommagetrennter String. Jeder Eintrag kann `ada@example.com` oder `Ada Lovelace <ada@example.com>` sein. Bis zu 50.

- `cc` (string | string[]): Empfänger in Kopie. Bis zu 50.

- `bcc` (string | string[]): Empfänger in Blindkopie. Bis zu 50. Sie erscheinen nicht in den Headern der Nachricht.

- `reply_to` (string | string[]): Adressen für Antworten. Wenn Sie mit einer Vorlage senden und dieses Feld weglassen, wird die Reply-To-Adresse der Vorlage verwendet.

- `subject` (string): Die Betreffzeile. Erforderlich, sofern `template` keinen liefert.

- `html` (string): Der HTML-Inhalt. Sie brauchen `html`, `text` oder beides, sofern `template` keinen Inhalt liefert.

- `text` (string): Der Nur-Text-Inhalt. Wenn Sie sowohl `html` als auch `text` senden, erhalten Empfänger eine Multipart-Nachricht.

- `template` (string): Eine zu sendende Vorlage. Übergeben Sie eine Vorlagen-ID (`tem_…`), um genau diese Version zu verwenden, oder einen Alias, um dessen veröffentlichte Version zu verwenden. `subject`, `html` und `text` in der Anfrage überschreiben die Werte der Vorlage. Siehe [Vorlagen](/de/docs/templates/).

- `variables` (object): Werte für Platzhalter von [Temple](/de/docs/templates/temple/) wie `{{first_name}}`, die in Betreff, HTML und Text gerendert werden. Funktioniert mit Vorlagen und mit Inhalt direkt in der Anfrage.

- `attachments` (object[]): Anzuhängende Dateien. Siehe [Anhang-Objekt](#attachment-object) unten.

- `headers` (object): Zusätzliche MIME-Header als Name-Wert-Paare, zum Beispiel `{"List-Unsubscribe": "<https://acme.com/unsubscribe>"}`. Emailit setzt `Message-ID` selbst.

- `meta` (object): Ihre eigenen Daten als Schlüssel-Wert-Paare, zum Beispiel `{"order_id": "1042"}`. Werte müssen Strings sein. Werden mit der E-Mail gespeichert und in Lesezugriffen und Webhook-Payloads mitgeliefert.

- `scheduled_at` (string): Wann gesendet werden soll, als Datum mit Uhrzeit nach ISO 8601 wie `2026-10-02T09:00:00Z` oder auf Englisch wie `tomorrow at 9am`. Geben Sie bei Werten nach ISO 8601 eine Zeitzone an. Ein Zeitpunkt in der Vergangenheit oder ein Wert, der sich nicht parsen lässt (auch ein Unix-Zeitstempel), sendet die E-Mail sofort. Geplante E-Mails haben bis zum Senden den Status `scheduled`.

- `tracking` (boolean | object): Aktiviert oder deaktiviert Öffnungs- und Klick-Tracking für diese E-Mail: `true`, `false` oder `{"loads": true, "clicks": false}`. Standardmäßig gelten die Einstellungen der Versanddomain. Tracking funktioniert nur, wenn der [Tracking-CNAME](/de/docs/tracking/custom-tracking-domain/) der Domain verifiziert ist; andernfalls ist es deaktiviert und die Antwort zeigt `false`.

### Anhang-Objekt

- `filename` (string, erforderlich): Der Dateiname einschließlich einer erlaubten Endung (siehe unten).

- `content` (string): Die Datei, Base64-kodiert. Senden Sie `content` oder `url`, nicht beides.

- `url` (string): Eine öffentliche `http`- oder `https`-URL, von der die Datei heruntergeladen wird. Emailit ruft sie beim Senden ab: Der Download muss innerhalb von 30 Sekunden abgeschlossen sein, darf höchstens 25 MB groß sein und darf nicht weiterleiten.

- `content_type` (string): Der MIME-Typ, etwa `application/pdf`. Erforderlich mit `content`. Bei `url` standardmäßig der Typ, den der Server zurückgibt.

- `content_id` (string): Bettet den Anhang ein. Verweisen Sie im HTML mit `<img src="cid:logo">` darauf, wenn `content_id` den Wert `logo` hat.

- `encoding` (string): Die Kodierung von `content`, etwa `base64` oder `hex`.

Die gesamte Nachricht einschließlich Anhängen darf bis zu 40 MB groß sein. Diese Dateitypen sind erlaubt:

| Kategorie | Endungen |
| --- | --- |
| Text | `.txt`, `.csv`, `.log`, `.css`, `.ics`, `.xml` |
| Bilder | `.jpg`, `.jpe`, `.jpeg`, `.gif`, `.png`, `.bmp`, `.psd`, `.tif`, `.tiff`, `.svg`, `.indd`, `.ai`, `.eps` |
| Dokumente | `.doc`, `.docx`, `.rtf`, `.odt`, `.ott`, `.pdf`, `.pub`, `.pages`, `.mobi`, `.epub` |
| Audio | `.mp3`, `.m4a`, `.m4v`, `.wma`, `.ogg`, `.flac`, `.wav`, `.aif`, `.aifc`, `.aiff` |
| Video | `.mp4`, `.mov`, `.avi`, `.mkv`, `.mpeg`, `.mpg`, `.wmv` |
| Tabellen | `.xls`, `.xlsx`, `.ods`, `.numbers` |
| Präsentationen | `.odp`, `.ppt`, `.pptx`, `.pps`, `.key` |
| Archive | `.zip`, `.vcf` |
| E-Mail | `.eml` |
| Kryptografie | `.p7c`, `.p7m`, `.p7s`, `.pgp`, `.asc`, `.sig` |

## Rückgabe

Gibt `200` mit dem E-Mail-Objekt des ersten Empfängers zurück. Hat die Nachricht über `to`, `cc` und `bcc` hinweg mehr als einen Empfänger, ordnet `ids` jedem Empfänger die ID seiner Kopie zu. Jede Kopie löst das Event [`email.accepted`](/de/docs/webhooks/events/email/accepted/) oder [`email.scheduled`](/de/docs/webhooks/events/email/scheduled/) aus.

- `object` (string): Immer `email`.

- `id` (string): Die ID der E-Mail des ersten Empfängers.

- `ids` (object): Zuordnung von Empfängeradresse zu E-Mail-ID für jeden Empfänger. Nur vorhanden, wenn es mehr als einen Empfänger gibt.

- `token` (string): Das interne Token der ersten E-Mail.

- `message_id` (string): Der Header `Message-ID` der ersten E-Mail, etwa `<token@acme.com>`.

- `from` (string): Der Absender, so wie Sie ihn gesendet haben.

- `to` (string[]): Die Adressen in `to`, ohne Anzeigenamen und ohne Duplikate.

- `cc` (string[]): Die Empfänger in `cc`. Nur vorhanden, wenn Sie welche gesendet haben.

- `bcc` (string[]): Die Empfänger in `bcc`. Nur vorhanden, wenn Sie welche gesendet haben.

- `subject` (string): Der Betreff nach dem Rendern von Vorlage und Variablen.

- `status` (string): `accepted` oder `scheduled` bei einem `scheduled_at` in der Zukunft.

- `scheduled_at` (string | null): Wann die E-Mail gesendet wird, oder `null`.

- `created_at` (string): Zeitpunkt, zu dem die E-Mail angenommen wurde.

- `tracking` (object): Das geltende Tracking: die Booleans `loads` und `clicks`.

**Anfrage** `POST /emails`

**Node.js**

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

const email = await emailit.emails.send({
  from: 'Acme <hello@acme.com>',
  to: ['ada@example.com', 'grace@example.com'],
  subject: 'Welcome to Acme',
  html: '<h1>Welcome!</h1><p>Thanks for signing up.</p>',
  tracking: {
    loads: true,
    clicks: true,
  },
});
```

**Python**

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

email = client.emails.send({
  "from": "Acme <hello@acme.com>",
  "to": ["ada@example.com", "grace@example.com"],
  "subject": "Welcome to Acme",
  "html": "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
  "tracking": {
    "loads": True,
    "clicks": True
  }
})
```

**PHP**

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

$email = $emailit->emails()->send([
  'from' => 'Acme <hello@acme.com>',
  'to' => ['ada@example.com', 'grace@example.com'],
  'subject' => 'Welcome to Acme',
  'html' => '<h1>Welcome!</h1><p>Thanks for signing up.</p>',
  'tracking' => [
    'loads' => true,
    'clicks' => true,
  ],
]);
```

**Ruby**

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

email = client.emails.send(
  from: "Acme <hello@acme.com>",
  to: ["ada@example.com", "grace@example.com"],
  subject: "Welcome to Acme",
  html: "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
  tracking: { loads: true, clicks: true }
)
```

**Go**

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

email, err := client.Emails.Send(&emailit.SendEmailRequest{
  From:    "Acme <hello@acme.com>",
  To:      []string{"ada@example.com", "grace@example.com"},
  Subject: "Welcome to Acme",
  Html:    "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
  Tracking: &emailit.TrackingOptions{
    Loads:  true,
    Clicks: true,
  },
})
```

**Rust**

```rust
use emailit::Emailit;
use emailit::types::CreateEmailBaseOptions;

let emailit = Emailit::new("your_api_key");

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

let email = emailit.emails.send(opts).await?;
```

**Java**

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

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().send(
  EmailSendParams.builder()
    .setFrom("Acme <hello@acme.com>")
    .setTo(Arrays.asList("ada@example.com", "grace@example.com"))
    .setSubject("Welcome to Acme")
    .setHtml("<h1>Welcome!</h1><p>Thanks for signing up.</p>")
    .setTracking(new TrackingOptions(true, true))
    .build()
);
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Send(new EmailSendOptions {
  From = "Acme <hello@acme.com>",
  To = new[] { "ada@example.com", "grace@example.com" },
  Subject = "Welcome to Acme",
  Html = "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
  Tracking = new TrackingOptions { Loads = true, Clicks = true },
});
```

**Laravel**

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

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

**cURL**

```bash
curl -X POST 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", "grace@example.com"],
    "subject": "Welcome to Acme",
    "html": "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
    "tracking": {
      "loads": true,
      "clicks": true
    }
  }'
```

**cURL**

```bash
curl -X POST 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",
    "template": "welcome",
    "variables": {
      "first_name": "Ada",
      "activation_url": "https://acme.com/activate?token=8f2c1e"
    }
  }'
```

**Node.js**

```javascript
const email = await emailit.emails.send({
  from: 'Acme <hello@acme.com>',
  to: 'ada@example.com',
  template: 'welcome',
  variables: {
    first_name: 'Ada',
    activation_url: 'https://acme.com/activate?token=8f2c1e',
  },
});
```

**Python**

```python
email = client.emails.send({
  "from": "Acme <hello@acme.com>",
  "to": "ada@example.com",
  "template": "welcome",
  "variables": {
    "first_name": "Ada",
    "activation_url": "https://acme.com/activate?token=8f2c1e"
  }
})
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "Acme Billing <billing@acme.com>",
    "to": "ada@example.com",
    "subject": "Your invoice INV-1042",
    "html": "<img src=\"cid:logo\"><p>Your invoice is attached.</p>",
    "attachments": [
      {
        "filename": "INV-1042.pdf",
        "content": "JVBERi0xLjQKJcOkw7zDqc...",
        "content_type": "application/pdf"
      },
      {
        "filename": "logo.png",
        "url": "https://acme.com/assets/logo.png",
        "content_id": "logo"
      }
    ]
  }'
```

**Node.js**

```javascript
import { readFile } from 'node:fs/promises';

const pdf = await readFile('INV-1042.pdf');

const email = await emailit.emails.send({
  from: 'Acme Billing <billing@acme.com>',
  to: 'ada@example.com',
  subject: 'Your invoice INV-1042',
  html: '<img src="cid:logo"><p>Your invoice is attached.</p>',
  attachments: [
    {
      filename: 'INV-1042.pdf',
      content: pdf.toString('base64'),
      content_type: 'application/pdf',
    },
    {
      filename: 'logo.png',
      url: 'https://acme.com/assets/logo.png',
      content_id: 'logo',
    },
  ],
});
```

**Python**

```python
import base64

with open("INV-1042.pdf", "rb") as f:
    pdf = base64.b64encode(f.read()).decode()

email = client.emails.send({
  "from": "Acme Billing <billing@acme.com>",
  "to": "ada@example.com",
  "subject": "Your invoice INV-1042",
  "html": '<img src="cid:logo"><p>Your invoice is attached.</p>',
  "attachments": [
    {"filename": "INV-1042.pdf", "content": pdf, "content_type": "application/pdf"},
    {"filename": "logo.png", "url": "https://acme.com/assets/logo.png", "content_id": "logo"}
  ]
})
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: reminder-appt-5531" \
  -d '{
    "from": "Acme <reminders@acme.com>",
    "to": "ada@example.com",
    "subject": "Your appointment tomorrow",
    "text": "See you tomorrow at 2 PM.",
    "scheduled_at": "2026-10-02T09:00:00Z",
    "meta": { "appointment_id": "5531" }
  }'
```

**Node.js**

```javascript
const email = await emailit.emails.send({
  from: 'Acme <reminders@acme.com>',
  to: 'ada@example.com',
  subject: 'Your appointment tomorrow',
  text: 'See you tomorrow at 2 PM.',
  scheduled_at: '2026-10-02T09:00:00Z',
  meta: { appointment_id: '5531' },
});
```

**Python**

```python
email = client.emails.send({
  "from": "Acme <reminders@acme.com>",
  "to": "ada@example.com",
  "subject": "Your appointment tomorrow",
  "text": "See you tomorrow at 2 PM.",
  "scheduled_at": "2026-10-02T09:00:00Z",
  "meta": {"appointment_id": "5531"}
})
```

**200**

```json
{
  "object": "email",
  "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "ids": {
    "ada@example.com": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
    "grace@example.com": "em_4KfIXZSV8v8L1k0Mg2YDR3rytvj"
  },
  "token": "4KDY1iIpQSSW5pAoiz3JEfqcsO0",
  "message_id": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
  "from": "Acme <hello@acme.com>",
  "to": ["ada@example.com", "grace@example.com"],
  "subject": "Welcome to Acme",
  "status": "accepted",
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.482913Z",
  "tracking": {
    "loads": true,
    "clicks": true
  }
}
```

**200 Geplant**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "token": "4KWzEED2cnej6UMjF4v508VqQIp",
  "message_id": "<4KWzEED2cnej6UMjF4v508VqQIp@acme.com>",
  "from": "Acme <reminders@acme.com>",
  "to": ["ada@example.com"],
  "subject": "Your appointment tomorrow",
  "status": "scheduled",
  "scheduled_at": "2026-10-02T09:00:00.000Z",
  "created_at": "2026-10-01T09:30:12.482913Z",
  "tracking": {
    "loads": false,
    "clicks": false
  }
}
```

**400**

```json
{
  "error": "Validation failed",
  "validation_errors": [
    "Missing required field: subject",
    "Invalid to email address at index 1: grace@example"
  ]
}
```

**402**

```json
{
  "error": "Insufficient credits",
  "message": "Insufficient credits to send this email. Required: 2, available: 0."
}
```

**403 Nicht verifiziert**

```json
{
  "code": "unverified_workspace_recipient",
  "error": "Workspace not verified",
  "message": "Unverified workspaces can only send to workspace members' account emails. Blocked recipient: grace@example.com.",
  "blocked_recipients": ["grace@example.com"]
}
```

**403 Domain**

```json
{
  "error": "Domain not authorized",
  "message": "API key is not authorized to send from this domain"
}
```

**404**

```json
{
  "error": "Template not found",
  "message": "Template 'welcome' not found or not published"
}
```

**413**

```json
{
  "error": "Message too large",
  "message": "Message size (41.27MB) exceeds maximum allowed size of 40MB"
}
```

**422**

```json
{
  "error": "Domain not verified"
}
```

**429**

```json
{
  "error": "Rate limit exceeded",
  "message": "Too many requests. Maximum 2 messages per second allowed.",
  "limit": 2,
  "current": 2,
  "retry_after": 1
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/emails/send/

## E-Mails auflisten — GET /emails

> Die ausgehenden oder eingehenden E-Mails eines Workspaces auflisten, die neuesten zuerst, mit Suche, Filtern, Sortierung und einem Standardfenster von 14 Tagen.

# E-Mails auflisten

Gibt eine Seite mit E-Mails zurück, die neuesten zuerst. Standardmäßig zeigt die Liste ausgehende E-Mails der letzten 14 Tage.

`GET /emails`

Erfordert einen API-Schlüssel mit dem Scope `full`. Jeder Empfänger einer Sendung ist in dieser Liste eine eigene E-Mail.

## Query-Parameter

- `page` (integer): Die abzurufende Seite.

- `limit` (integer): E-Mails pro Seite, von 1 bis 100.

- `type` (string): `outbound` für E-Mails, die Sie gesendet haben, oder `inbound` für E-Mails, die Sie [empfangen](/de/docs/inbound/) haben.

- `date_from` (string): Nur E-Mails, die an oder nach diesem Datum erstellt wurden, etwa `2026-08-01` (ab 00:00 UTC). Ohne diesen Parameter beginnt die Liste vor 14 Tagen. Filter auf `created_at` ändern dieses Fenster nicht.

- `date_to` (string): Nur E-Mails, die an oder vor diesem Datum erstellt wurden, bis 23:59:59 UTC.

- `search` (string): Abgleich mit Empfänger, Absender oder Betreff, ohne Beachtung der Groß-/Kleinschreibung.

- `match` (string): `all` oder `or`. Wie die Filter unten kombiniert werden.

- `order` (string): Ein Sortierschlüssel aus der Tabelle unten.

- `direction` (string): `asc` oder `desc`.

## Filter

Fügen Sie Filter in der Form `key.condition=value` hinzu, zum Beispiel `status.exact=bounced` oder `created_at.after=2026-09-01`. Die Bedingungen für jeden Typ finden Sie unter [Filtern](/de/docs/api-reference/filtering/).

| Schlüssel | Typ | Werte und Hinweise |
| --- | --- | --- |
| `to` | String | Empfängeradresse. |
| `from` | String | Absender wie gesendet, einschließlich eines etwaigen Anzeigenamens. |
| `subject` | String | |
| `status` | Enum | `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled`, `held` |
| `tag` | String | Das Tag der E-Mail. Beim Senden per API oder SMTP wird derzeit kein Tag gesetzt. |
| `spam_score` | Zahl | |
| `created_at` | Datum | |
| `updated_at` | Datum | |
| `api_key_id` | String | ID des API-Schlüssels, der die E-Mail gesendet hat (`key_…`). |
| `sending_domain_id` | String | ID der Versanddomain (`dom_…`). |

Jeder Schlüssel ist auch ein Sortierschlüssel. Die älteren Query-Parameter `status`, `rcpt_to`, `mail_from`, `subject`, `api_key_id` und `sending_domain_id` funktionieren weiterhin: `status` prüft auf exakte Übereinstimmung, die Parameter für Adressen und Betreff auf Teilübereinstimmung.

## Rückgabe

Gibt ein Array `data` mit E-Mail-Objekten sowie `next_page_url` und `previous_page_url` zurück. Siehe [Paginierung](/de/docs/api-reference/pagination/). Die Seiten-URLs enthalten Ihre Filter nicht. Rufen Sie die nächste Seite daher mit Ihren eigenen Parametern und einem um eins erhöhten `page` ab.

- `object` (string): Immer `email`.

- `id` (string): Die ID der E-Mail.

- `type` (string): `outbound` oder `inbound`.

- `from` (string): Der Absender wie gesendet.

- `to` (string): Der Empfänger dieser Kopie.

- `subject` (string): Der Betreff.

- `status` (string): Der aktuelle [Status](/de/docs/logs/email-statuses/).

- `size` (integer): Größe der Nachricht in Byte.

- `scheduled_at` (string | null): Wann eine geplante E-Mail fällig ist, oder `null`.

- `created_at` (string): Zeitpunkt, zu dem die E-Mail angenommen oder empfangen wurde.

- `updated_at` (string): Zeitpunkt der letzten Statusänderung.

- `meta` (object | null): Die von Ihnen gesendeten `meta`.

**Anfrage** `GET /emails`

**Node.js**

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

const emails = await emailit.emails.list({ page: 1, limit: 25 });
```

**Python**

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

emails = client.emails.list({ "page": 1, "limit": 25 })
```

**PHP**

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

$emails = $emailit->emails()->list(['page' => 1, 'limit' => 25]);
```

**Ruby**

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

emails = client.emails.list(page: 1, limit: 25)
```

**Go**

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

emails, err := client.Emails.List(&emailit.ListEmailsRequest{
  Page:  1,
  Limit: 25,
})
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let emails = emailit.emails.list(Some(emailit::types::ListEmailsParams {
  page: Some(1),
  limit: Some(25),
})).await?;
```

**Java**

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

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject emails = emailit.emails().list(
  EmailListParams.builder()
    .setPage(1)
    .setLimit(25)
    .build()
);
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var emails = emailit.Emails.List(new EmailListOptions {
  Page = 1,
  Limit = 25,
});
```

**Laravel**

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

$emails = Emailit::emails()->list(['page' => 1, 'limit' => 25]);
```

**cURL**

```bash
curl -G https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d page=1 \
  -d limit=25
```

**cURL**

```bash
curl -G https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d status.exact=bounced \
  -d status.exact=failed \
  -d match=or \
  -d date_from=2026-09-01 \
  -d order=created_at \
  -d direction=desc
```

**200**

```json
{
  "data": [
    {
      "object": "email",
      "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
      "type": "outbound",
      "from": "Acme <hello@acme.com>",
      "to": "ada@example.com",
      "subject": "Welcome to Acme",
      "status": "delivered",
      "size": 4523,
      "scheduled_at": null,
      "created_at": "2026-10-01T09:30:12.482913Z",
      "updated_at": "2026-10-01T09:30:14.118204Z",
      "meta": null
    },
    {
      "object": "email",
      "id": "em_4KfIXZSV8v8L1k0Mg2YDR3rytvj",
      "type": "outbound",
      "from": "Acme <hello@acme.com>",
      "to": "grace@example.com",
      "subject": "Welcome to Acme",
      "status": "loaded",
      "size": 4527,
      "scheduled_at": null,
      "created_at": "2026-10-01T09:30:12.482913Z",
      "updated_at": "2026-10-01T09:41:03.770521Z",
      "meta": null
    }
  ],
  "next_page_url": "/app/v2/emails?page=2&limit=25",
  "previous_page_url": null
}
```

**400**

```json
{
  "statusCode": 400,
  "error": "Bad Request",
  "message": "Validation error",
  "details": [
    {
      "instancePath": "/limit",
      "schemaPath": "#/properties/limit/maximum",
      "keyword": "maximum",
      "params": { "comparison": "<=", "limit": 100 },
      "message": "must be <= 100"
    }
  ]
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/emails/list/

## E-Mail abrufen — GET /emails/{id}

> Eine ausgehende oder eingehende E-Mail per ID abrufen, mit Status, Headern, geparstem HTML- und Text-Inhalt, Metadaten und Anhängen.

# E-Mail abrufen

Ruft eine E-Mail mit Status, geparsten Headern, HTML- und Text-Inhalt sowie Anhängen ab.

`GET /emails/{id}`

Erfordert einen API-Schlüssel mit dem Scope `full`. Nachrichteninhalte werden für die [Aufbewahrungsdauer](/de/docs/data-retention/) für Inhalte in Ihrem Tarif gespeichert. Danach sind `headers`, `body` und `attachments` leer, Status und Metadaten bleiben erhalten. Um nur einen Teil einer E-Mail abzurufen, verwenden Sie [Body abrufen](/de/docs/api-reference/emails/body/), [Metadaten abrufen](/de/docs/api-reference/emails/meta/), [Anhänge auflisten](/de/docs/api-reference/emails/attachments/) oder [Roh-MIME abrufen](/de/docs/api-reference/emails/raw/).

## Pfadparameter

- `id` (string, erforderlich): Die ID der E-Mail, etwa `em_4KYof1ZzXndZE2VPi0DgULiekG8`.

## Rückgabe

Gibt das E-Mail-Objekt zurück.

- `object` (string): Immer `email`.

- `id` (string): Die ID der E-Mail.

- `type` (string): `outbound` für E-Mails, die Sie gesendet haben, `inbound` für E-Mails, die Sie empfangen haben.

- `token` (string): Das interne Token der E-Mail.

- `message_id` (string): Der Header `Message-ID`.

- `from` (string): Der Absender wie gesendet, etwa `Acme <hello@acme.com>`.

- `to` (string): Der Empfänger dieser Kopie.

- `subject` (string): Der Betreff.

- `status` (string): Der aktuelle Status: `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled` oder `held`. Siehe [E-Mail-Status](/de/docs/logs/email-statuses/).

- `size` (integer): Größe der Nachricht in Byte.

- `scheduled_at` (string | null): Wann eine geplante E-Mail fällig ist, oder `null`.

- `created_at` (string): Zeitpunkt, zu dem die E-Mail angenommen oder empfangen wurde.

- `updated_at` (string): Zeitpunkt der letzten Änderung der E-Mail.

- `tracking` (object): Nur bei ausgehenden E-Mails. Ob Öffnungs-Tracking (`loads`) und Klick-Tracking (`clicks`) aktiviert sind.

- `meta` (object | null): Die von Ihnen gesendeten `meta` oder `null`.

- `headers` (object | null): Die Header der Nachricht als Name-Wert-Paare oder `null`, sobald der Inhalt gelöscht wurde.

- `body` (object): `text` und `html`, jeweils ein String oder `null`.

- `attachments` (object[]): Die Anhänge, jeweils mit `filename`, `content_type`, `size` in Byte, `content_id` (für eingebettete Dateien), `content_disposition` (`attachment` oder `inline`) und `content` (Base64).

**Anfrage** `GET /emails/{id}`

**Node.js**

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

const email = await emailit.emails.get('em_4KYof1ZzXndZE2VPi0DgULiekG8');
```

**Python**

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

email = client.emails.get("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**PHP**

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

$email = $emailit->emails()->get('em_4KYof1ZzXndZE2VPi0DgULiekG8');
```

**Ruby**

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

email = client.emails.get("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Go**

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

email, err := client.Emails.Get("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.get("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import com.emailit.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().get("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Get("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

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

$email = Emailit::emails()->get('em_4KYof1ZzXndZE2VPi0DgULiekG8');
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8 \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200 Ausgehend**

```json
{
  "object": "email",
  "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "type": "outbound",
  "token": "4KDY1iIpQSSW5pAoiz3JEfqcsO0",
  "message_id": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
  "from": "Acme Billing <billing@acme.com>",
  "to": "ada@example.com",
  "subject": "Your invoice INV-1042",
  "status": "delivered",
  "size": 48213,
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.482913Z",
  "updated_at": "2026-10-01T09:30:14.118204Z",
  "tracking": {
    "loads": true,
    "clicks": true
  },
  "meta": {
    "invoice_id": "INV-1042"
  },
  "headers": {
    "From": "Acme Billing <billing@acme.com>",
    "To": "ada@example.com",
    "Subject": "Your invoice INV-1042",
    "Message-ID": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
    "MIME-Version": "1.0",
    "Content-Type": "multipart/mixed; boundary=\"--_NmP-4f1c2a9e7b3d0e5f-Part_1\""
  },
  "body": {
    "text": "Your invoice is attached.",
    "html": "<p>Your invoice is attached.</p>"
  },
  "attachments": [
    {
      "filename": "INV-1042.pdf",
      "content_type": "application/pdf",
      "size": 40960,
      "content_id": null,
      "content_disposition": "attachment",
      "content": "JVBERi0xLjQKJcOkw7zDqc..."
    }
  ]
}
```

**200 Eingehend**

```json
{
  "object": "email",
  "id": "em_4KbeG9poqTmjvQZeN8pMoJkCVNd",
  "type": "inbound",
  "token": "4KTnDU5PzzqDqp8UWb9qVhPVFOT",
  "message_id": "<CAH7x2k9@mail.example.com>",
  "from": "Ada Lovelace <ada@example.com>",
  "to": "support@inbound.acme.com",
  "subject": "Re: Your invoice INV-1042",
  "status": "received",
  "size": 8234,
  "scheduled_at": null,
  "created_at": "2026-10-01T11:02:45.031877Z",
  "updated_at": "2026-10-01T11:02:45.031877Z",
  "meta": null,
  "headers": {
    "From": "Ada Lovelace <ada@example.com>",
    "To": "support@inbound.acme.com",
    "Subject": "Re: Your invoice INV-1042",
    "Content-Type": "text/plain; charset=utf-8"
  },
  "body": {
    "text": "Thanks, received.",
    "html": null
  },
  "attachments": []
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/emails/get/

## Roh-MIME abrufen — GET /emails/{id}/raw

> Die vollständige Roh-MIME-Quelle einer E-Mail mit ihren Headern abrufen, zusammen mit Status und Metadaten der E-Mail.

# Roh-MIME abrufen

Ruft die vollständige MIME-Quelle einer E-Mail so ab, wie Emailit sie gespeichert hat, zusammen mit ihren Metadaten.

`GET /emails/{id}/raw`

Erfordert einen API-Schlüssel mit dem Scope `full`. Verwenden Sie diesen Endpunkt, um eine Nachricht zu archivieren, ihre Struktur zu debuggen oder sie mit Ihrer eigenen MIME-Bibliothek zu parsen. Sobald die [Aufbewahrungsdauer](/de/docs/data-retention/) für Inhalte abgelaufen ist, sind `raw` und `headers` `null`.

## Pfadparameter

- `id` (string, erforderlich): Die ID der E-Mail.

## Rückgabe

Gibt die Metadaten der E-Mail wie bei [Metadaten abrufen](/de/docs/api-reference/emails/meta/) zurück, jedoch ohne `attachments`, und zusätzlich die Rohnachricht.

- `raw` (string | null): Die vollständige MIME-Nachricht: die Header, eine Leerzeile und der Body. `null`, sobald der Inhalt gelöscht wurde.

- `headers` (object | null): Die Header der obersten Ebene als Name-Wert-Paare.

Die übrigen Felder (`object`, `id`, `type`, `token`, `message_id`, `from`, `to`, `subject`, `status`, `size`, `scheduled_at`, `created_at`, `updated_at`, `tracking` und `meta`) sind dieselben wie bei [E-Mail abrufen](/de/docs/api-reference/emails/get/).

**Anfrage** `GET /emails/{id}/raw`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const raw = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw",
  headers={"Authorization": "Bearer your_api_key"}
)
raw = response.json()
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$raw = json_decode(curl_exec($ch), true);
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
raw = JSON.parse(http.request(req).body)
```

**Go**

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

raw, err := client.Emails.GetRaw("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let raw = emailit.emails.get_raw("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var raw = emailit.Emails.GetRaw("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$raw = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw')
  ->json();
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "email",
  "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "type": "outbound",
  "token": "4KDY1iIpQSSW5pAoiz3JEfqcsO0",
  "message_id": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
  "from": "Acme <hello@acme.com>",
  "to": "ada@example.com",
  "subject": "Welcome to Acme",
  "status": "delivered",
  "size": 1342,
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.482913Z",
  "updated_at": "2026-10-01T09:30:14.118204Z",
  "tracking": {
    "loads": false,
    "clicks": false
  },
  "meta": null,
  "headers": {
    "From": "Acme <hello@acme.com>",
    "To": "ada@example.com",
    "Subject": "Welcome to Acme",
    "Message-ID": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
    "MIME-Version": "1.0",
    "Content-Type": "text/html; charset=utf-8"
  },
  "raw": "From: Acme <hello@acme.com>\r\nTo: ada@example.com\r\nSubject: Welcome to Acme\r\nMessage-ID: <4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>\r\nMIME-Version: 1.0\r\nContent-Type: text/html; charset=utf-8\r\nContent-Transfer-Encoding: quoted-printable\r\n\r\n<h1>Welcome!</h1><p>Thanks for signing up.</p>"
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/emails/raw/

## Anhänge auflisten — GET /emails/{id}/attachments

> Die Anhänge einer E-Mail mit Dateinamen, MIME-Typen, Größen, Content-IDs eingebetteter Bilder und Base64-kodiertem Inhalt auflisten.

# Anhänge auflisten

Gibt die Anhänge einer E-Mail einschließlich ihres Inhalts zurück.

`GET /emails/{id}/attachments`

Erfordert einen API-Schlüssel mit dem Scope `full`. Funktioniert für ausgehende und eingehende E-Mails. Eingebettete Bilder (Teile mit einer `Content-ID`) sind enthalten. Um die Liste ohne Dateiinhalte abzurufen, verwenden Sie [Metadaten abrufen](/de/docs/api-reference/emails/meta/). Sobald die [Aufbewahrungsdauer](/de/docs/data-retention/) für Inhalte abgelaufen ist, ist die Liste leer.

## Pfadparameter

- `id` (string, erforderlich): Die ID der E-Mail.

## Rückgabe

Gibt ein Listenobjekt mit allen Anhängen zurück. Die Liste ist nicht paginiert.

- `object` (string): Immer `list`.

- `data` (object[]): Die Anhänge.

- `data[].filename` (string): Der Dateiname.

- `data[].content_type` (string): Der MIME-Typ, etwa `application/pdf`.

- `data[].size` (integer): Größe der dekodierten Datei in Byte.

- `data[].content_id` (string | null): Die `Content-ID` eines eingebetteten Anhangs oder `null`.

- `data[].content_disposition` (string | null): `attachment` oder `inline`.

- `data[].content` (string): Die Datei, Base64-kodiert.

**Anfrage** `GET /emails/{id}/attachments`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const attachments = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments",
  headers={"Authorization": "Bearer your_api_key"}
)
attachments = response.json()
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$attachments = json_decode(curl_exec($ch), true);
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
attachments = JSON.parse(http.request(req).body)
```

**Go**

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

attachments, err := client.Emails.GetAttachments("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let attachments = emailit.emails.get_attachments("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var attachments = emailit.Emails.GetAttachments("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$attachments = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments')
  ->json();
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "list",
  "data": [
    {
      "filename": "INV-1042.pdf",
      "content_type": "application/pdf",
      "size": 40960,
      "content_id": null,
      "content_disposition": "attachment",
      "content": "JVBERi0xLjQKJcOkw7zDqc..."
    },
    {
      "filename": "logo.png",
      "content_type": "image/png",
      "size": 5120,
      "content_id": "logo",
      "content_disposition": "inline",
      "content": "iVBORw0KGgoAAAANSUhEUgAA..."
    }
  ]
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/emails/attachments/

## Body abrufen — GET /emails/{id}/body

> Nur den geparsten HTML- und Nur-Text-Inhalt einer E-Mail abrufen, ohne Header, Metadaten oder Anhänge.

# Body abrufen

Gibt den HTML- und Nur-Text-Inhalt einer E-Mail zurück, dekodiert aus ihren MIME-Teilen.

`GET /emails/{id}/body`

Erfordert einen API-Schlüssel mit dem Scope `full`. Funktioniert für ausgehende und eingehende E-Mails. Bei ausgehenden E-Mails ist der Body das, was gesendet wurde, nach dem Rendern von Vorlage und Variablen. Sobald die [Aufbewahrungsdauer](/de/docs/data-retention/) für Inhalte abgelaufen ist, sind beide Felder `null`.

## Pfadparameter

- `id` (string, erforderlich): Die ID der E-Mail.

## Rückgabe

- `text` (string | null): Der Nur-Text-Teil oder `null`, wenn die E-Mail keinen hat.

- `html` (string | null): Der HTML-Teil oder `null`, wenn die E-Mail keinen hat.

**Anfrage** `GET /emails/{id}/body`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const body = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body",
  headers={"Authorization": "Bearer your_api_key"}
)
body = response.json()
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$body = json_decode(curl_exec($ch), true);
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
body = JSON.parse(http.request(req).body)
```

**Go**

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

body, err := client.Emails.GetBody("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let body = emailit.emails.get_body("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var body = emailit.Emails.GetBody("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$body = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body')
  ->json();
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "text": "Welcome!\n\nThanks for signing up.",
  "html": "<h1>Welcome!</h1><p>Thanks for signing up.</p>"
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/emails/body/

## Metadaten abrufen — GET /emails/{id}/meta

> Status, Header, Metadaten und Anhangsliste einer E-Mail abrufen, ohne den Body der Nachricht oder die Inhalte der Anhänge herunterzuladen.

# Metadaten abrufen

Ruft eine E-Mail ohne ihren Body ab: Status, Header, Ihre `meta`-Daten und die Liste der Anhänge ohne deren Inhalt.

`GET /emails/{id}/meta`

Erfordert einen API-Schlüssel mit dem Scope `full`. Das ist der schlankste Weg, die Details einer E-Mail zu lesen, wenn Sie den Inhalt nicht brauchen.

## Pfadparameter

- `id` (string, erforderlich): Die ID der E-Mail.

## Rückgabe

Gibt dieselben Felder wie [E-Mail abrufen](/de/docs/api-reference/emails/get/) zurück, ohne `body` und mit `attachments` nur als Beschreibung, ohne Inhalt:

- `attachments` (object[]): Für jeden Anhang `filename`, `content_type`, `size`, `content_id` und `content_disposition`. Kein `content`.

- `headers` (object | null): Die Header der Nachricht als Name-Wert-Paare oder `null`, sobald der Inhalt gelöscht wurde.

- `meta` (object | null): Die `meta`, die Sie mit der E-Mail gesendet haben.

**Anfrage** `GET /emails/{id}/meta`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const meta = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta",
  headers={"Authorization": "Bearer your_api_key"}
)
meta = response.json()
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$meta = json_decode(curl_exec($ch), true);
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
meta = JSON.parse(http.request(req).body)
```

**Go**

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

meta, err := client.Emails.GetMeta("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let meta = emailit.emails.get_meta("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var meta = emailit.Emails.GetMeta("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$meta = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta')
  ->json();
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "email",
  "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "type": "outbound",
  "token": "4KDY1iIpQSSW5pAoiz3JEfqcsO0",
  "message_id": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
  "from": "Acme Billing <billing@acme.com>",
  "to": "ada@example.com",
  "subject": "Your invoice INV-1042",
  "status": "delivered",
  "size": 48213,
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.482913Z",
  "updated_at": "2026-10-01T09:30:14.118204Z",
  "tracking": {
    "loads": true,
    "clicks": true
  },
  "meta": {
    "invoice_id": "INV-1042"
  },
  "headers": {
    "From": "Acme Billing <billing@acme.com>",
    "To": "ada@example.com",
    "Subject": "Your invoice INV-1042",
    "Message-ID": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
    "MIME-Version": "1.0",
    "Content-Type": "multipart/mixed; boundary=\"--_NmP-4f1c2a9e7b3d0e5f-Part_1\""
  },
  "attachments": [
    {
      "filename": "INV-1042.pdf",
      "content_type": "application/pdf",
      "size": 40960,
      "content_id": null,
      "content_disposition": "attachment"
    }
  ]
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/emails/meta/

## Geplante E-Mail aktualisieren — POST /emails/{id}

> Den Sendezeitpunkt einer geplanten E-Mail ändern. Möglich bis drei Minuten vor dem Termin, und der neue Zeitpunkt muss mindestens drei Minuten in der Zukunft liegen.

# Geplante E-Mail aktualisieren

Verschiebt eine geplante E-Mail auf einen neuen Sendezeitpunkt.

`POST /emails/{id}`

Funktioniert mit API-Schlüsseln mit dem Scope `sending` oder `full`. Sie können nur eine E-Mail verschieben, deren Status `scheduled` ist und deren aktueller Sendezeitpunkt mehr als 3 Minuten entfernt ist. Nur der Sendezeitpunkt lässt sich ändern; um den Inhalt zu ändern, [stornieren](/de/docs/api-reference/emails/cancel/) Sie die E-Mail und senden eine neue.

Eine geplante Sendung an mehrere Empfänger erzeugt eine E-Mail pro Empfänger. Verschieben Sie jede ID aus der Zuordnung `ids` der [Antwort beim Senden](/de/docs/api-reference/emails/send/).

## Pfadparameter

- `id` (string, erforderlich): Die ID der geplanten E-Mail.

## Body-Parameter

- `scheduled_at` (string, erforderlich): Der neue Sendezeitpunkt, als Datum mit Uhrzeit nach ISO 8601 wie `2026-10-03T09:00:00Z` oder auf Englisch wie `tomorrow at 3pm`. Er muss mehr als 3 Minuten in der Zukunft liegen.

## Rückgabe

- `object` (string): Immer `email`.

- `id` (string): Die ID der E-Mail.

- `status` (string): Immer `scheduled`.

- `scheduled_at` (string): Der neue Sendezeitpunkt.

- `updated_at` (string): Zeitpunkt der Aktualisierung der E-Mail.

- `message` (string): Eine Bestätigungsmeldung.

Gibt `422` zurück, wenn die E-Mail nicht geplant ist, innerhalb von 3 Minuten fällig ist oder der neue Zeitpunkt nicht geparst werden kann oder zu früh liegt.

**Anfrage** `POST /emails/{id}`

**Node.js**

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

const email = await emailit.emails.update('em_4K76IA5sFNIsLXW9QC2ro8cDbOj', {
  scheduled_at: '2026-10-03T09:00:00Z',
});
```

**Python**

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

email = client.emails.update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj", {
  "scheduled_at": "2026-10-03T09:00:00Z"
})
```

**PHP**

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

$email = $emailit->emails()->update('em_4K76IA5sFNIsLXW9QC2ro8cDbOj', [
  'scheduled_at' => '2026-10-03T09:00:00Z',
]);
```

**Ruby**

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

email = client.emails.update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  scheduled_at: "2026-10-03T09:00:00Z"
)
```

**Go**

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

email, err := client.Emails.Update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj", &emailit.UpdateEmailRequest{
  ScheduledAt: "2026-10-03T09:00:00Z",
})
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj", emailit::types::UpdateEmailParams {
  scheduled_at: "2026-10-03T09:00:00Z".to_string(),
}).await?;
```

**Java**

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

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  EmailUpdateParams.builder()
    .setScheduledAt("2026-10-03T09:00:00Z")
    .build()
);
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj", new EmailUpdateOptions {
  ScheduledAt = "2026-10-03T09:00:00Z",
});
```

**Laravel**

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

$email = Emailit::emails()->update('em_4K76IA5sFNIsLXW9QC2ro8cDbOj', [
  'scheduled_at' => '2026-10-03T09:00:00Z',
]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4K76IA5sFNIsLXW9QC2ro8cDbOj \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scheduled_at": "2026-10-03T09:00:00Z"}'
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4K76IA5sFNIsLXW9QC2ro8cDbOj \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scheduled_at": "tomorrow at 3pm"}'
```

**200**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "status": "scheduled",
  "scheduled_at": "2026-10-03T09:00:00.000Z",
  "updated_at": "2026-10-01T10:15:40.207316Z",
  "message": "Email schedule has been updated successfully"
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4K76IA5sFNIsLXW9QC2ro8cDbOj' not found in your workspace"
}
```

**422 Nicht geplant**

```json
{
  "error": "Cannot update email",
  "message": "Email cannot be updated. Current status: 'delivered'. Only 'scheduled' emails can be updated."
}
```

**422 Zu spät**

```json
{
  "error": "Cannot update email",
  "message": "Scheduled emails can only be updated at least 3 minutes before the scheduled time. This email is scheduled to send in 2 minute(s)."
}
```

**422 Ungültige Zeit**

```json
{
  "error": "Invalid scheduled_at",
  "message": "The new scheduled time must be at least 3 minutes in the future."
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/emails/update/

## E-Mail stornieren — POST /emails/{id}/cancel

> Eine geplante, angenommene oder vorübergehend fehlgeschlagene E-Mail stornieren und aus der Versandwarteschlange entfernen. Ohne Garantie: Eine bereits laufende Zustellung kann noch abgeschlossen werden.

# E-Mail stornieren

Entfernt eine E-Mail aus der Versandwarteschlange und setzt ihren Status auf `canceled`.

`POST /emails/{id}/cancel`

Funktioniert mit API-Schlüsseln mit dem Scope `sending` oder `full`. Das Stornieren erfolgt ohne Garantie: Die E-Mail wird aus der Warteschlange genommen, aber wenn ein Zustellversuch bereits begonnen hat, kann dieser Versuch noch abgeschlossen werden, und nur die restlichen Wiederholungen werden gestoppt. Welcher Fall vorliegt, zeigt die Antwort in `in_flight`. Das Stornieren löst das [Event](/de/docs/webhooks/event-types/) `email.canceled` aus, und der Credit wird nicht erstattet. Die Aktion **Cancel delivery** in der Weboberfläche tut dasselbe.

| Status | Stornierbar | Hinweise |
| --- | --- | --- |
| `scheduled` | Ja | Bis 3 Minuten vor dem geplanten Zeitpunkt. |
| `accepted` | Ja | In der Warteschlange und noch nicht zugestellt. |
| `attempted` | Ja | Stoppt die restlichen Wiederholungen nach einem vorübergehenden Fehler. |
| Alle anderen | Nein | Die E-Mail wurde bereits zugestellt, ist fehlgeschlagen oder wurde storniert. |

Um eine Sendung mit mehreren Empfängern zu stornieren, stornieren Sie jede ID aus der Zuordnung `ids` der [Antwort beim Senden](/de/docs/api-reference/emails/send/).

## Pfadparameter

- `id` (string, erforderlich): Die ID der E-Mail.

## Rückgabe

- `object` (string): Immer `email`.

- `id` (string): Die ID der E-Mail.

- `status` (string): Immer `canceled`.

- `in_flight` (boolean): `true`, wenn ein Zustellversuch womöglich bereits läuft und noch abgeschlossen werden könnte. `false`, wenn die E-Mail vor jedem Versuch aus der Warteschlange entfernt wurde.

- `message` (string): Eine Beschreibung des Ergebnisses.

**Anfrage** `POST /emails/{id}/cancel`

**Node.js**

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

const email = await emailit.emails.cancel('em_4K76IA5sFNIsLXW9QC2ro8cDbOj');
```

**Python**

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

email = client.emails.cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj")
```

**PHP**

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

$email = $emailit->emails()->cancel('em_4K76IA5sFNIsLXW9QC2ro8cDbOj');
```

**Ruby**

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

email = client.emails.cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj")
```

**Go**

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

email, err := client.Emails.Cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj").await?;
```

**Java**

```java
import com.emailit.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj");
```

**Laravel**

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

$email = Emailit::emails()->cancel('em_4K76IA5sFNIsLXW9QC2ro8cDbOj');
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4K76IA5sFNIsLXW9QC2ro8cDbOj/cancel \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "status": "canceled",
  "in_flight": false,
  "message": "Email has been canceled and removed from the send queue."
}
```

**200 Zustellung läuft**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "status": "canceled",
  "in_flight": true,
  "message": "Email was canceled. The current delivery attempt may still complete; remaining retries were stopped."
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4K76IA5sFNIsLXW9QC2ro8cDbOj' not found in your workspace"
}
```

**422 Status**

```json
{
  "error": "Cannot cancel email",
  "message": "Email cannot be canceled. Current status: 'delivered'. Only 'scheduled', 'accepted', or 'attempted' emails can be canceled."
}
```

**422 Zu spät**

```json
{
  "error": "Cannot cancel email",
  "message": "Scheduled emails can only be canceled at least 3 minutes before the scheduled time. This email is scheduled to send in 2 minute(s)."
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/emails/cancel/

## E-Mail erneut senden — POST /emails/{id}/retry

> Eine gebouncte, fehlgeschlagene, gesperrte oder zurückgehaltene E-Mail als neue E-Mail mit neuer ID erneut senden. Das Original bleibt unverändert.

# E-Mail erneut senden

Stellt eine Kopie einer E-Mail, die nicht durchgekommen ist, in die Warteschlange. Die Kopie ist eine neue E-Mail mit eigener ID, und das Original behält seinen Status.

`POST /emails/{id}/retry`

Funktioniert mit API-Schlüsseln mit dem Scope `sending` oder `full`. Die Kopie hat denselben Absender, Empfänger, Betreff, Inhalt, dieselben Header, `meta` und Tracking-Einstellungen, aber eine neue `Message-ID`. Sie kostet Credits wie eine neue Sendung: einen Credit, bei einer Kampagnen-E-Mail zwei.

Sie können eine E-Mail erneut senden, wenn:

- ihr Status `bounced`, `failed`, `suppressed` oder `held` ist,
- sie in den letzten 30 Tagen erstellt wurde,
- ihr Inhalt nicht durch Ihre [Aufbewahrungsdauer](/de/docs/data-retention/) gelöscht wurde und ihre Versanddomain noch existiert.

Beheben Sie zuerst die Ursache. Eine gesperrte Adresse, die noch auf Ihrer [Sperrliste](/de/docs/suppressions/) steht, wird erneut gesperrt, und eine [zurückgehaltene](/de/docs/logs/email-statuses/) E-Mail wird erneut zurückgehalten, bis der Grund dafür behoben ist.

## Pfadparameter

- `id` (string, erforderlich): Die ID der E-Mail, die erneut gesendet werden soll.

## Rückgabe

- `object` (string): Immer `email`.

- `id` (string): Die ID der neuen E-Mail.

- `original_id` (string): Die ID der erneut gesendeten E-Mail.

- `token` (string): Das interne Token der neuen E-Mail.

- `message_id` (string): Die `Message-ID` der neuen E-Mail.

- `from` (string): Der Absender.

- `to` (string): Der Empfänger.

- `subject` (string): Der Betreff.

- `status` (string): Immer `accepted`.

- `created_at` (string): Zeitpunkt der Erstellung der neuen E-Mail.

- `message` (string): Eine Bestätigungsmeldung.

**Anfrage** `POST /emails/{id}/retry`

**Node.js**

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

const email = await emailit.emails.retry('em_4KKrQ7TzsVtzsS8zG069B2aMtoK');
```

**Python**

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

email = client.emails.retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK")
```

**PHP**

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

$email = $emailit->emails()->retry('em_4KKrQ7TzsVtzsS8zG069B2aMtoK');
```

**Ruby**

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

email = client.emails.retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK")
```

**Go**

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

email, err := client.Emails.Retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK").await?;
```

**Java**

```java
import com.emailit.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK");
```

**Laravel**

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

$email = Emailit::emails()->retry('em_4KKrQ7TzsVtzsS8zG069B2aMtoK');
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4KKrQ7TzsVtzsS8zG069B2aMtoK/retry \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "email",
  "id": "em_4KbeG9poqTmjvQZeN8pMoJkCVNd",
  "original_id": "em_4KKrQ7TzsVtzsS8zG069B2aMtoK",
  "token": "4KTnDU5PzzqDqp8UWb9qVhPVFOT",
  "message_id": "<4KTnDU5PzzqDqp8UWb9qVhPVFOT@acme.com>",
  "from": "Acme <hello@acme.com>",
  "to": "ada@example.com",
  "subject": "Welcome to Acme",
  "status": "accepted",
  "created_at": "2026-10-01T12:04:51.330482Z",
  "message": "Email has been queued for retry"
}
```

**402**

```json
{
  "error": "Insufficient credits",
  "message": "Insufficient credits to retry this email. Required: 1, available: 0."
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KKrQ7TzsVtzsS8zG069B2aMtoK' not found in your workspace"
}
```

**422 Status**

```json
{
  "error": "Cannot retry email",
  "message": "Only bounced, failed, suppressed, or held emails can be retried. Current status: 'delivered'"
}
```

**422 Zu alt**

```json
{
  "error": "Cannot retry email",
  "message": "Emails older than 30 days cannot be retried"
}
```

**422 Gelöscht**

```json
{
  "error": "Cannot retry email",
  "message": "Email raw content has been purged and can no longer be retried"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/emails/retry/

## E-Mail weiterleiten — POST /emails/{id}/forward

> Eine ausgehende E-Mail erneut an neue Empfänger senden, als einfache Kopie oder mit einem Weiterleitungsblock und einer optionalen Notiz. Begrenzt auf 3 pro Stunde.

# E-Mail weiterleiten

Sendet den Inhalt einer ausgehenden E-Mail als neue E-Mail an neue Empfänger. Die ursprüngliche E-Mail bleibt unverändert.

`POST /emails/{id}/forward`

Funktioniert mit API-Schlüsseln mit dem Scope `sending` oder `full`. Standardmäßig ist die Weiterleitung ein einfaches erneutes Senden von HTML, Text und Anhängen des Originals. Setzen Sie `include_headers`, um über dem ursprünglichen Inhalt einen Block „Forwarded message“ und eine optionale Notiz einzufügen.

Eine Weiterleitung ist eine neue Sendung. Daher gelten die Regeln von [E-Mail senden](/de/docs/api-reference/emails/send/): Die Adresse in `from` muss auf einer verifizierten Versanddomain liegen, jeder Empfänger kostet einen Credit und zählt zu den [Versandlimits](/de/docs/api-reference/rate-limits/), das Tracking folgt den Einstellungen der Domain, und der Header `Idempotency-Key` wird unterstützt. Zusätzlich kann ein Workspace höchstens 3 E-Mails pro Stunde weiterleiten.

Nur ausgehende E-Mails lassen sich weiterleiten, und nur solange ihr Inhalt im Rahmen Ihrer [Aufbewahrungsdauer](/de/docs/data-retention/) gespeichert ist. Um empfangene E-Mails weiterzuleiten, verwenden Sie eine [Automatisierung](/de/docs/inbound/forward-with-automations/).

## Pfadparameter

- `id` (string, erforderlich): Die ID der ausgehenden E-Mail, die weitergeleitet werden soll.

## Header

- `Idempotency-Key` (string): Macht die Weiterleitung gefahrlos wiederholbar. Siehe [Idempotenz](/de/docs/api-reference/idempotency/).

## Body-Parameter

- `to` (string | string[], erforderlich): Die neuen Empfänger, als Array oder als kommagetrennter String. Bis zu 50.

- `include_headers` (boolean): Bei `true` wird ein Block „Forwarded message“ mit ursprünglichem Absender, Datum, Betreff und Empfänger eingefügt und darüber Ihre Notiz. Bei `false` wird der ursprüngliche Inhalt unverändert erneut gesendet.

- `comment` (string): Eine Nur-Text-Notiz über der weitergeleiteten Nachricht. Wird nur mit `include_headers` verwendet. `body` wird als Alias akzeptiert.

- `html` (string): Eine HTML-Notiz, die im HTML-Teil anstelle des maskierten `comment` verwendet wird. Wird nur mit `include_headers` verwendet.

- `text` (string): Eine Nur-Text-Notiz, die im Text-Teil anstelle von `comment` verwendet wird. Wird nur mit `include_headers` verwendet.

- `from` (string): Der Absender. Standardmäßig der `from` der ursprünglichen E-Mail.

- `subject` (string): Der Betreff. Standardmäßig der ursprüngliche Betreff, mit `include_headers` `Fwd: ` gefolgt vom ursprünglichen Betreff.

Ursprüngliche Anhänge werden übernommen, wenn ihr Dateityp [erlaubt](/de/docs/api-reference/emails/send/#attachment-object) ist.

## Rückgabe

Gibt dasselbe Objekt wie [E-Mail senden](/de/docs/api-reference/emails/send/) zurück, mit zwei zusätzlichen Feldern:

- `original_id` (string): Die ID der weitergeleiteten E-Mail.

- `message` (string): Eine Bestätigungsmeldung.

Über dem Limit für Weiterleitungen gibt die API `429` mit dem Header `retry-after` zurück.

**Anfrage** `POST /emails/{id}/forward`

**Node.js**

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

const email = await emailit.emails.forward('em_4KYof1ZzXndZE2VPi0DgULiekG8', {
  to: 'grace@example.com',
});
```

**Python**

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

email = client.emails.forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", {
  "to": "grace@example.com",
})
```

**PHP**

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

$email = $emailit->emails()->forward('em_4KYof1ZzXndZE2VPi0DgULiekG8', [
  'to' => 'grace@example.com',
]);
```

**Ruby**

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

email = client.emails.forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", {
  to: "grace@example.com"
})
```

**Go**

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

email, err := client.Emails.Forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", emailit.ForwardEmailRequest{
  To: "grace@example.com",
})
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", ForwardEmail {
    to: "grace@example.com".into(),
    ..Default::default()
}).await?;
```

**Java**

```java
import com.emailit.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", Map.of(
  "to", "grace@example.com"
));
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", new ForwardEmailRequest {
  To = "grace@example.com"
});
```

**Laravel**

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

$email = Emailit::emails()->forward('em_4KYof1ZzXndZE2VPi0DgULiekG8', [
  'to' => 'grace@example.com',
]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/forward \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "to": "grace@example.com"
  }'
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/forward \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: fwd-inv-1042-grace" \
  -d '{
    "to": ["grace@example.com"],
    "include_headers": true,
    "comment": "Grace, here is the invoice Ada asked about."
  }'
```

**Node.js**

```javascript
const email = await emailit.emails.forward('em_4KYof1ZzXndZE2VPi0DgULiekG8', {
  to: ['grace@example.com'],
  include_headers: true,
  comment: 'Grace, here is the invoice Ada asked about.',
});
```

**Python**

```python
email = client.emails.forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", {
  "to": ["grace@example.com"],
  "include_headers": True,
  "comment": "Grace, here is the invoice Ada asked about."
})
```

**200**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "original_id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "token": "4KWzEED2cnej6UMjF4v508VqQIp",
  "message_id": "<4KWzEED2cnej6UMjF4v508VqQIp@acme.com>",
  "from": "Acme Billing <billing@acme.com>",
  "to": ["grace@example.com"],
  "subject": "Fwd: Your invoice INV-1042",
  "status": "accepted",
  "scheduled_at": null,
  "created_at": "2026-10-01T13:20:07.915203Z",
  "tracking": {
    "loads": true,
    "clicks": true
  },
  "message": "Email has been queued for forwarding"
}
```

**400**

```json
{
  "error": "Validation failed",
  "validation_errors": ["Invalid to email address at index 0: grace@example"]
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

**422 Eingehend**

```json
{
  "error": "Cannot forward email",
  "message": "Only outgoing emails can be forwarded"
}
```

**422 Gelöscht**

```json
{
  "error": "Cannot forward email",
  "message": "Email raw content has been purged and can no longer be forwarded"
}
```

**429**

```json
{
  "error": "too_many_requests",
  "message": "Forwarding is limited to 3 emails per hour for this workspace. Try again later.",
  "limit": 3,
  "current": 4,
  "retry_after": 2711
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/emails/forward/

## Nur den Status abrufen — GET /email/{id}

> Nur den aktuellen Zustellstatus einer E-Mail per ID abrufen, ohne Header, Inhalt oder Metadaten, für schnelle Statusprüfungen.

# Nur den Status abrufen

Gibt nur den aktuellen Status einer E-Mail zurück.

`GET /email/{id}`

Erfordert einen API-Schlüssel mit dem Scope `full`. Beachten Sie den Singular `/email` im Pfad. Die Antwort ist klein, daher eignet sich dieser Endpunkt gut für schnelle Statusprüfungen. Für Statusänderungen in Echtzeit verwenden Sie [Webhooks](/de/docs/webhooks/), statt regelmäßig abzufragen.

## Pfadparameter

- `id` (string, erforderlich): Die ID der E-Mail.

## Rückgabe

- `status` (string): Der aktuelle Status: `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled` oder `held`. Siehe [E-Mail-Status](/de/docs/logs/email-statuses/).

**Anfrage** `GET /email/{id}`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const { status } = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8",
  headers={"Authorization": "Bearer your_api_key"}
)
status = response.json()["status"]
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$status = json_decode(curl_exec($ch), true)['status'];
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
status = JSON.parse(http.request(req).body)["status"]
```

**Go**

```go
req, _ := http.NewRequest("GET", "https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8", nil)
req.Header.Set("Authorization", "Bearer your_api_key")

resp, err := http.DefaultClient.Do(req)
if err != nil {
  return err
}
defer resp.Body.Close()

var result struct {
  Status string `json:"status"`
}
err = json.NewDecoder(resp.Body).Decode(&result)
```

**Rust**

```rust
let response: serde_json::Value = reqwest::Client::new()
    .get("https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8")
    .bearer_auth("your_api_key")
    .send()
    .await?
    .json()
    .await?;
let status = response["status"].as_str();
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using System.Net.Http.Headers;
using System.Net.Http.Json;

var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "your_api_key");

var result = await http.GetFromJsonAsync<Dictionary<string, string>>(
  "https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8");
var status = result["status"];
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$status = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8')
  ->json('status');
```

**cURL**

```bash
curl https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8 \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "status": "delivered"
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/emails/status/