Emailit
Dokumentation API-Referenz E-Mails

E-Mail senden

Versenden Sie eine einzelne E-Mail an einen oder mehrere Empfänger. Unterstützt Vorlagen, Variablen, Anhänge, Terminplanung und Tracking.

POST /emails
## Header
Authorization string Required

Bearer-Token für die Authentifizierung.

Idempotency-Key string

Eindeutiger Schlüssel (max. 256 Zeichen, alphanumerisch/Bindestrich/Unterstrich) zur Vermeidung doppelter Sendungen für 24 Stunden.

## Request Body
from string Required

Absender-E-Mail im RFC-Format: email@domain.com oder Anzeigename <email@domain.com>.

to string | string[] Required

E-Mail-Adresse(n) der Empfänger. Maximal 50 Empfänger.

subject string

Betreffzeile der E-Mail. Erforderlich, außer die Vorlage stellt sie bereit.

html string

HTML-Inhalt der E-Mail. Erforderlich, außer die Vorlage stellt ihn bereit oder Text ist vorhanden.

text string

Nur-Text-Inhalt der E-Mail.

reply_to string | string[]

Antwort-an-E-Mail-Adresse(n).

cc string | string[]

CC-Empfänger. Maximal 50 Empfänger.

bcc string | string[]

BCC-Empfänger. Maximal 50 Empfänger.

template string

Vorlagen-Alias oder ID (tem_xxx Format).

variables object

Variablen für Vorlagen-Substitution mit {{variable}}-Syntax.

attachments array

Array von Anhang-Objekten (siehe Anhang-Objekt unten).

headers object

Benutzerdefinierte E-Mail-Header als Schlüssel-Wert-Paare.

meta object

Metadaten als Schlüssel-Wert-String-Paare. Werden mit der E-Mail gespeichert und zurückgegeben.

scheduled_at string

Geplante Sendezeit. Akzeptiert ISO 8601, Unix-Zeitstempel oder natürliche Sprache wie morgen um 9 Uhr.

tracking boolean | object

Überschreibt Domain-Tracking-Standardeinstellungen. Kann ein Boolean oder Objekt mit loads- und clicks-Eigenschaften sein.

## Anhang-Objekt
filename string Required

Dateiname mit Erweiterung.

content string

Base64-kodierter Inhalt. Schließt sich gegenseitig mit url aus.

url string

URL zum Abrufen des Anhangs. Schließt sich gegenseitig mit content aus.

content_type string

MIME-Typ. Erforderlich bei Verwendung von content.

content_id string

Content-ID für Inline-Bilder (cid:).

encoding string

Content-Encoding (Standard: base64).

## Zulässige Anhang-Dateitypen
Kategorie Erweiterungen
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
Kryptografisch .p7c, .p7m, .p7s, .pgp, .asc, .sig

Rate-Limit-Header

Die folgenden Header sind in jeder Antwort enthalten:

Header Beschreibung
ratelimit-limit Maximale Anfragen pro Sekunde
ratelimit-remaining Verbleibende Anfragen in der aktuellen Sekunde
ratelimit-reset Sekunden bis zum Reset des Rate-Limits
ratelimit-daily-limit Maximale tägliche Anfragen
ratelimit-daily-remaining Verbleibende tägliche Anfragen
ratelimit-daily-reset Sekunden bis zum Reset des Tageslimits

::code-snippet{title=“E-Mail senden”}

const response = await fetch('https://api.emailit.com/v2/emails', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    from: 'Ihr Unternehmen <hello@ihredomain.com>',
    to: ['empfaenger1@example.com', 'empfaenger2@example.com'],
    subject: 'Hallo Welt',
    html: '<h1>Willkommen!</h1><p>Vielen Dank für Ihre Anmeldung.</p>',
    tracking: {
      loads: true,
      clicks: true
    }
  })
});

const result = await response.json();
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => 'https://api.emailit.com/v2/emails',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_POSTFIELDS => json_encode([
    'from' => 'Ihr Unternehmen <hello@ihredomain.com>',
    'to' => ['empfaenger1@example.com', 'empfaenger2@example.com'],
    'subject' => 'Hallo Welt',
    'html' => '<h1>Willkommen!</h1><p>Vielen Dank für Ihre Anmeldung.</p>',
    'tracking' => [
      'loads' => true,
      'clicks' => true
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type: application/json'
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  $result = json_decode($response, true);
  print_r($result);
}
import requests

response = requests.post(
    'https://api.emailit.com/v2/emails',
    headers={
        'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
        'Content-Type': 'application/json'
    },
    json={
        'from': 'Ihr Unternehmen <hello@ihredomain.com>',
        'to': ['empfaenger1@example.com', 'empfaenger2@example.com'],
        'subject': 'Hallo Welt',
        'html': '<h1>Willkommen!</h1><p>Vielen Dank für Ihre Anmeldung.</p>',
        'tracking': {
            'loads': True,
            'clicks': True
        }
    }
)

result = response.json()
print(result)
require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/emails')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'
request.body = {
  from: 'Ihr Unternehmen <hello@ihredomain.com>',
  to: ['empfaenger1@example.com', 'empfaenger2@example.com'],
  subject: 'Hallo Welt',
  html: '<h1>Willkommen!</h1><p>Vielen Dank für Ihre Anmeldung.</p>',
  tracking: {
    loads: true,
    clicks: true
  }
}.to_json

response = http.request(request)
result = JSON.parse(response.body)
puts result
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    url := "https://api.emailit.com/v2/emails"
    
    data := map[string]interface{}{
        "from": "Ihr Unternehmen <hello@ihredomain.com>",
        "to": []string{"empfaenger1@example.com", "empfaenger2@example.com"},
        "subject": "Hallo Welt",
        "html": "<h1>Willkommen!</h1><p>Vielen Dank für Ihre Anmeldung.</p>",
        "tracking": map[string]bool{
            "loads": true,
            "clicks": true,
        },
    }
    
    jsonData, _ := json.Marshal(data)
    
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer em_test_

E-Mails auflisten

Listet E-Mails in Ihrem Arbeitsbereich mit Paginierung und optionaler Filterung nach Typ auf.

GET/emails

Abfrageparameter

pageinteger

Seitennummer. Minimum: 1. Standard: 1.

limitinteger

Anzahl der Ergebnisse pro Seite. Bereich: 1–100. Standard: 10.

typestring

Filterung nach E-Mail-Typ: inbound (eingehend) oder outbound (ausgehend).

const response = await fetch('https://api.emailit.com/v2/emails?page=1&limit=10', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();
<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/emails?page=1&limit=10',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "cURL-Fehler #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}
import requests

response = requests.get(
'https://api.emailit.com/v2/emails',
params={'page': 1, 'limit': 10},
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)
require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/emails?page=1&limit=10')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result
package main

import (
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/emails?page=1&limit=10"

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}
use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/emails?page=1&limit=10")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class ListEmails {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails?page=1&limit=10"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .GET()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class ListEmails
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.GetAsync(
            "https://api.emailit.com/v2/emails?page=1&limit=10");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}
curl -X GET "https://api.emailit.com/v2/emails?page=1&limit=10" \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"
{
"data": [
{
  "object": "email",
  "id": "em_abc123xyz789def456ghi012jkl345",
  "type": "outbound",
  "from": "absender@ihredomain.com",
  "to": "empfaenger@beispiel.com",
  "subject": "Hallo Welt",
  "status": "delivered",
  "size": 4523,
  "scheduled_at": null,
  "created_at": "2026-01-08T12:00:00.123456Z",
  "updated_at": "2026-01-08T12:01:00.123456Z",
  "meta": null
},
{
  "object": "email",
  "id": "em_def456ghi789jkl012mno345pqr678",
  "type": "inbound",
  "from": "extern@anderedomain.com",
  "to": "posteingang@ihredomain.com",
  "subject": "Re: Ihre Anfrage",
  "status": "delivered",
  "size": 2891,
  "scheduled_at": null,
  "created_at": "2026-01-08T11:30:00.123456Z",
  "updated_at": "2026-01-08T11:30:00.123456Z",
  "meta": null
}
],
"next_page_url": "/v2/emails?page=2&limit=10",
"previous_page_url": null
}

E-Mail abrufen

Ruft eine einzelne E-Mail anhand ihrer ID ab, einschließlich Header, geparster Inhalte und Anhänge.

GET/emails/{id}

Pfad-Parameter

idstringRequired

Die E-Mail-ID im Format em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();
<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/emails/em_abc123xyz789def456',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "cURL-Fehler #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}
import requests

response = requests.get(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)
require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/emails/em_abc123xyz789def456')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result
package main

import (
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/emails/em_abc123xyz789def456"

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}
use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/emails/em_abc123xyz789def456")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class GetEmail {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .GET()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class GetEmail
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.GetAsync(
            "https://api.emailit.com/v2/emails/em_abc123xyz789def456");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}
curl -X GET https://api.emailit.com/v2/emails/em_abc123xyz789def456 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

Antwort-Felder

FeldTypBeschreibung
objectstringImmer "email"
idstringE-Mail-ID im Format em_xxx
typestring"inbound" oder "outbound"
tokenstringE-Mail-Token
message_idstringSMTP Message-ID
fromstringAbsender-E-Mail-Adresse
tostringEmpfänger-E-Mail-Adresse
subjectstringE-Mail-Betreff
statusstringAktueller E-Mail-Status
sizeintegerE-Mail-Größe in Bytes
scheduled_atstring | nullGeplante Zustellzeit (ISO 8601)
created_atstringErstellungszeitpunkt (ISO 8601)
updated_atstringZeitpunkt der letzten Aktualisierung (ISO 8601)
trackingobject | nullTracking-Einstellungen (entfällt bei eingehenden E-Mails)
metaobject | nullBenutzerdefinierte Metadaten
headersobjectGeparste E-Mail-Header
bodyobjectGeparster Inhalt mit text- und html-Feldern
attachmentsarrayGeparste Anhänge mit base64-kodiertem Inhalt

Body-Objekt

FeldTypBeschreibung
textstring | nullNur-Text-Inhalt
htmlstring | nullHTML-Inhalt

Anhang-Objekt

FeldTypBeschreibung
filenamestringDateiname des Anhangs
content_typestringMIME-Typ
sizeintegerAnhang-Größe in Bytes
content_idstring | nullContent-ID für eingebettete Anhänge
content_dispositionstring"attachment" oder "inline"
contentstringBase64-kodierter Anhang-Inhalt
{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"type": "outbound",
"token": "abc123xyz789",
"message_id": "<abc123xyz789@ihredomain.com>",
"from": "absender@ihredomain.com",
"to": "empfaenger@beispiel.com",
"subject": "Hallo Welt",
"status": "delivered",
"size": 12345,
"scheduled_at": null,
"created_at": "2026-01-08T12:00:00.123456Z",
"updated_at": "2026-01-08T12:05:00.123456Z",
"tracking": {
"loads": true,
"clicks": true
},
"meta": {
"campaign": "sommer",
"type": "marketing"
},
"headers": {
"From": "absender@ihredomain.com",
"To": "empfaenger@beispiel.com",
"Subject": "Hallo Welt",
"Content-Type": "multipart/mixed; boundary=----boundary123"
},
"body": {
"text": "Willkommen!",
"html": "<html><body><h1>Willkommen!</h1></body></html>"
},
"attachments": [
{
  "filename": "dokument.pdf",
  "content_type": "application/pdf",
  "size": 12345,
  "content_id": null,
  "content_disposition": "attachment",
  "content": "JVBERi0xLjQKJcOkw7zDqc..."
}
]
}
{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"type": "inbound",
"token": "abc123xyz789",
"message_id": "<abc123xyz789@externedomain.com>",
"from": "extern@externedomain.com",
"to": "posteingang@ihredomain.com",
"subject": "Re: Ihre Anfrage",
"status": "delivered",
"size": 8234,
"scheduled_at": null,
"created_at": "2026-01-08T12:00:00.123456Z",
"updated_at": "2026-01-08T12:00:00.123456Z",
"meta": null,
"headers": {
"From": "extern@externedomain.com",
"To": "posteingang@ihredomain.com",
"Subject": "Re: Ihre Anfrage",
"Content-Type": "text/plain; charset=utf-8"
},
"body": {
"text": "Vielen Dank für Ihre Nachricht...",
"html": null
},
"attachments": []
}
{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"type": "outbound",
"token": "abc123xyz789",
"message_id": "<abc123xyz789@ihredomain.com>",
"from": "absender@ihredomain.com",
"to": "empfaenger@beispiel.com",
"subject": "Terminerinnerung",
"status": "scheduled",
"size": 8234,
"scheduled_at": "2026-01-10T15:00:00.000000Z",
"created_at": "2026-01-08T12:00:00.123456Z",
"updated_at": "2026-01-08T12:00:00.123456Z",
"tracking": {
"loads": true,
"clicks": true
},
"meta": null,
"headers": {
"From": "absender@ihredomain.com",
"To": "empfaenger@beispiel.com",
"Subject": "Terminerinnerung",
"Content-Type": "text/html; charset=utf-8"
},
"body": {
"text": "Terminerinnerung...",
"html": "<html>..."
},
"attachments": []
}
{
"error": "E-Mail nicht gefunden",
"message": "E-Mail mit ID 'em_abc123' wurde in Ihrem Arbeitsbereich nicht gefunden"
}

E-Mail-Rohdaten abrufen

Gibt die vollständige MIME-Nachricht als Rohstring zusammen mit den E-Mail-Metadaten zurück.

GET/emails/{id}/raw

Pfad-Parameter

idstringRequired

Die E-Mail-ID im Format em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456/raw', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();
<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/emails/em_abc123xyz789def456/raw',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "cURL-Fehler #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}
import requests

response = requests.get(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456/raw',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)
require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/emails/em_abc123xyz789def456/raw')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result
package main

import (
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/emails/em_abc123xyz789def456/raw"

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}
use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/emails/em_abc123xyz789def456/raw")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class GetEmailRaw {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456/raw"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .GET()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class GetEmailRaw
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.GetAsync(
            "https://api.emailit.com/v2/emails/em_abc123xyz789def456/raw");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}
curl -X GET https://api.emailit.com/v2/emails/em_abc123xyz789def456/raw \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"
{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"type": "outbound",
"token": "abc123xyz789",
"message_id": "<abc123xyz789@yourdomain.com>",
"from": "sender@yourdomain.com",
"to": "recipient@example.com",
"subject": "Hallo Welt",
"status": "delivered",
"size": 4523,
"scheduled_at": null,
"created_at": "2026-01-08T12:00:00.123456Z",
"updated_at": "2026-01-08T12:05:00.123456Z",
"tracking": {
"loads": true,
"clicks": false
},
"meta": null,
"headers": {
"From": "sender@yourdomain.com",
"To": "recipient@example.com",
"Subject": "Hallo Welt",
"Content-Type": "text/html; charset=utf-8"
},
"raw": "From: sender@yourdomain.com\r\nTo: recipient@example.com\r\nSubject: Hallo Welt\r\nContent-Type: text/html; charset=utf-8\r\n\r\n<html><body><h1>Willkommen!</h1></body></html>"
}
{
"error": "E-Mail nicht gefunden",
"message": "E-Mail mit der ID 'em_abc123' wurde in Ihrem Arbeitsbereich nicht gefunden"
}

E-Mail-Anhänge abrufen

Gibt nur die Anhangsliste einer E-Mail zurück, mit base64-kodiertem Inhalt.

GET/emails/{id}/attachments

Pfad-Parameter

idstringRequired

Die E-Mail-ID im Format em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456/attachments', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();
<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/emails/em_abc123xyz789def456/attachments',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "cURL-Fehler #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}
import requests

response = requests.get(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456/attachments',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)
require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/emails/em_abc123xyz789def456/attachments')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result
package main

import (
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/emails/em_abc123xyz789def456/attachments"

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}
use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/emails/em_abc123xyz789def456/attachments")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class GetEmailAttachments {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456/attachments"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .GET()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class GetEmailAttachments
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.GetAsync(
            "https://api.emailit.com/v2/emails/em_abc123xyz789def456/attachments");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}
curl -X GET https://api.emailit.com/v2/emails/em_abc123xyz789def456/attachments \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

Antwort-Felder

FeldTypBeschreibung
objectstringImmer "list"
dataarrayArray von Anhang-Objekten

Anhang-Objekt

FeldTypBeschreibung
filenamestringDateiname des Anhangs
content_typestringMIME-Typ
sizeintegerGröße des Anhangs in Bytes
content_idstring | nullContent-ID für eingebettete Anhänge
content_dispositionstring"attachment" oder "inline"
contentstringBase64-kodierter Anhang-Inhalt
{
"object": "list",
"data": [
{
  "filename": "dokument.pdf",
  "content_type": "application/pdf",
  "size": 12345,
  "content_id": null,
  "content_disposition": "attachment",
  "content": "JVBERi0xLjQKJcOkw7zDqc..."
},
{
  "filename": "logo.png",
  "content_type": "image/png",
  "size": 5678,
  "content_id": "logo@ihredomain.com",
  "content_disposition": "inline",
  "content": "iVBORw0KGgoAAAANSUhEUg..."
}
]
}
{
"object": "list",
"data": []
}
{
"error": "E-Mail nicht gefunden",
"message": "E-Mail mit ID 'em_abc123' wurde in Ihrem Arbeitsbereich nicht gefunden"
}

E-Mail-Inhalt abrufen

Gibt nur den geparsten Inhalt (Text und HTML) einer E-Mail zurück.

GET/emails/{id}/body

Pfad-Parameter

idstringRequired

Die E-Mail-ID im Format em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456/body', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();
<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/emails/em_abc123xyz789def456/body',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "cURL-Fehler #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}
import requests

response = requests.get(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456/body',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)
require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/emails/em_abc123xyz789def456/body')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result
package main

import (
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/emails/em_abc123xyz789def456/body"

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}
use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/emails/em_abc123xyz789def456/body")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class GetEmailBody {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456/body"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .GET()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class GetEmailBody
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.GetAsync(
            "https://api.emailit.com/v2/emails/em_abc123xyz789def456/body");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}
curl -X GET https://api.emailit.com/v2/emails/em_abc123xyz789def456/body \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"
{
"text": "Klartext-Inhalt der E-Mail",
"html": "<html><body><h1>Willkommen!</h1><p>HTML-Inhalt der E-Mail</p></body></html>"
}
{
"text": "Klartext-Inhalt der E-Mail",
"html": null
}
{
"error": "E-Mail nicht gefunden",
"message": "E-Mail mit ID 'em_abc123' wurde in Ihrem Arbeitsbereich nicht gefunden"
}

E-Mail-Metadaten abrufen

Gibt E-Mail-Metadaten mit Anhang-Informationen zurück, jedoch ohne den Anhang-Inhalt. Nützlich zur Inspektion einer E-Mail, ohne potenziell große Anhang-Daten herunterladen zu müssen.

GET/emails/{id}/meta

Pfad-Parameter

idstringRequired

Die E-Mail-ID im Format em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456/meta', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();
<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/emails/em_abc123xyz789def456/meta',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "cURL-Fehler #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}
import requests

response = requests.get(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456/meta',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)
require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/emails/em_abc123xyz789def456/meta')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result
package main

import (
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/emails/em_abc123xyz789def456/meta"

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}
use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/emails/em_abc123xyz789def456/meta")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class GetEmailMeta {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456/meta"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .GET()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class GetEmailMeta
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.GetAsync(
            "https://api.emailit.com/v2/emails/em_abc123xyz789def456/meta");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}
curl -X GET https://api.emailit.com/v2/emails/em_abc123xyz789def456/meta \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

Antwort-Felder

Die Antwort enthält alle E-Mail-Metadaten-Felder sowie ein attachments-Array mit Anhang-Informationen (ohne das content-Feld).

Anhang-Objekt (Meta)

FeldTypBeschreibung
filenamestringDateiname des Anhangs
content_typestringMIME-Typ
sizeintegerAnhang-Größe in Bytes
content_idstring | nullContent-ID für eingebettete Anhänge
content_dispositionstring"attachment" oder "inline"
{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"type": "outbound",
"token": "abc123xyz789",
"message_id": "<abc123xyz789@yourdomain.com>",
"from": "sender@yourdomain.com",
"to": "recipient@example.com",
"subject": "Hallo Welt",
"status": "delivered",
"size": 4523,
"scheduled_at": null,
"created_at": "2026-01-08T12:00:00.123456Z",
"updated_at": "2026-01-08T12:05:00.123456Z",
"tracking": {
"loads": true,
"clicks": false
},
"meta": null,
"headers": {
"From": "sender@yourdomain.com",
"To": "recipient@example.com",
"Subject": "Hallo Welt",
"Content-Type": "multipart/mixed; boundary=----boundary123"
},
"attachments": [
{
  "filename": "dokument.pdf",
  "content_type": "application/pdf",
  "size": 12345,
  "content_id": null,
  "content_disposition": "attachment"
}
]
}
{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"type": "outbound",
"token": "abc123xyz789",
"message_id": "<abc123xyz789@yourdomain.com>",
"from": "sender@yourdomain.com",
"to": "recipient@example.com",
"subject": "Hallo Welt",
"status": "delivered",
"size": 4523,
"scheduled_at": null,
"created_at": "2026-01-08T12:00:00.123456Z",
"updated_at": "2026-01-08T12:05:00.123456Z",
"tracking": {
"loads": true,
"clicks": false
},
"meta": null,
"headers": {
"From": "sender@yourdomain.com",
"To": "recipient@example.com",
"Subject": "Hallo Welt",
"Content-Type": "text/html; charset=utf-8"
},
"attachments": []
}
{
"error": "E-Mail nicht gefunden",
"message": "E-Mail mit ID 'em_abc123' wurde in Ihrem Arbeitsbereich nicht gefunden"
}

Geplante E-Mail aktualisieren

Ändert den Sendezeitpunkt einer geplanten E-Mail. Funktioniert nur bei E-Mails mit dem Status “scheduled” und nur dann, wenn der aktuell geplante Sendezeitpunkt mindestens 3 Minuten in der Zukunft liegt.

POST/emails/{id}

Pfad-Parameter

idstringRequired

Die E-Mail-ID im Format em_xxx.

Request Body

scheduled_atstringRequired

Neuer geplanter Sendezeitpunkt. Akzeptiert ISO 8601-Format, Unix-Zeitstempel oder natürliche Sprache wie morgen um 9 Uhr. Muss mindestens 3 Minuten in der Zukunft liegen.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456', {
method: 'POST',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
},
body: JSON.stringify({
scheduled_at: '2026-01-10T15:00:00Z'
})
});

const result = await response.json();
<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/emails/em_abc123xyz789def456',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_POSTFIELDS => json_encode([
'scheduled_at' => '2026-01-10T15:00:00Z'
]),
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "cURL Fehler #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}
import requests

response = requests.post(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
},
json={
    'scheduled_at': '2026-01-10T15:00:00Z'
}
)

result = response.json()
print(result)
require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/emails/em_abc123xyz789def456')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'
request.body = {
scheduled_at: '2026-01-10T15:00:00Z'
}.to_json

response = http.request(request)
result = JSON.parse(response.body)
puts result
package main

import (
"bytes"
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/emails/em_abc123xyz789def456"

data := map[string]interface{}{
    "scheduled_at": "2026-01-10T15:00:00Z",
}

jsonData, _ := json.Marshal(data)

req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}
use reqwest;
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .post("https://api.emailit.com/v2/emails/em_abc123xyz789def456")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .json(&json!({
        "scheduled_at": "2026-01-10T15:00:00Z"
    }))
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.net.http.HttpRequest.BodyPublishers;

public class UpdateEmail {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    String jsonBody = "{\"scheduled_at\":\"2026-01-10T15:00:00Z\"}";
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .POST(BodyPublishers.ofString(jsonBody))
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class UpdateEmail
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var data = new { scheduled_at = "2026-01-10T15:00:00Z" };
        var json = JsonConvert.SerializeObject(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await client.PostAsync(
            "https://api.emailit.com/v2/emails/em_abc123xyz789def456", content);
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}
curl -X POST https://api.emailit.com/v2/emails/em_abc123xyz789def456 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json" \
-d '{
"scheduled_at": "2026-01-10T15:00:00Z"
}'
curl -X POST https://api.emailit.com/v2/emails/em_abc123xyz789def456 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json" \
-d '{
"scheduled_at": "morgen um 15 Uhr"
}'
{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"status": "scheduled",
"scheduled_at": "2026-01-10T15:00:00.000Z",
"updated_at": "2026-01-08T12:00:00.123456Z",
"message": "E-Mail-Zeitplan wurde erfolgreich aktualisiert"
}
{
"error": "E-Mail nicht gefunden",
"message": "E-Mail mit ID 'em_abc123' wurde in Ihrem Arbeitsbereich nicht gefunden"
}
{
"error": "E-Mail kann nicht aktualisiert werden",
"message": "Geplante E-Mails können nur bis mindestens 3 Minuten vor dem geplanten Sendezeitpunkt aktualisiert werden. Diese E-Mail soll in 2 Minute(n) gesendet werden."
}
{
"error": "Ungültiger scheduled_at-Wert",
"message": "Der neue geplante Sendezeitpunkt muss mindestens 3 Minuten in der Zukunft liegen."
}

E-Mail stornieren

Stornieren Sie eine geplante oder ausstehende E-Mail. Bei geplanten E-Mails ist eine Stornierung nur möglich, wenn der geplante Versandzeitpunkt mindestens 3 Minuten in der Zukunft liegt.

POST/emails/{id}/cancel

Pfad-Parameter

idstringRequired

Die E-Mail-ID im Format em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel', {
method: 'POST',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();
<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "cURL Fehler #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}
import requests

response = requests.post(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)
require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result
package main

import (
"encoding/json"
"fmt"
"net/http"
"strings"
)

func main() {
url := "https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel"

req, _ := http.NewRequest("POST", url, strings.NewReader(""))
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}
use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .post("https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.net.http.HttpRequest.BodyPublishers;

public class CancelEmail {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .POST(BodyPublishers.noBody())
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class CancelEmail
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.PostAsync(
            "https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel", 
            new StringContent(""));
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}
curl -X POST https://api.emailit.com/v2/emails/em_abc123xyz789def456/cancel \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"
{
"object": "email",
"id": "em_abc123xyz789def456ghi012jkl345",
"status": "canceled",
"message": "E-Mail wurde erfolgreich storniert"
}
{
"error": "E-Mail nicht gefunden",
"message": "E-Mail mit ID 'em_abc123' wurde in Ihrem Arbeitsbereich nicht gefunden"
}
{
"error": "E-Mail kann nicht storniert werden",
"message": "E-Mail kann nicht storniert werden. Aktueller Status: 'sent'. Nur E-Mails mit Status 'scheduled' oder 'pending' können storniert werden."
}
{
"error": "E-Mail kann nicht storniert werden",
"message": "Geplante E-Mails können nur mindestens 3 Minuten vor dem geplanten Versandzeitpunkt storniert werden. Diese E-Mail soll in 2 Minute(n) versendet werden."
}

Stornierbare E-Mail-Status

StatusStornierbar?Hinweise
pending✅ JaE-Mail ist in der Warteschlange, aber noch nicht verarbeitet
scheduled✅ JaNur wenn geplanter Zeitpunkt mindestens 3 Minuten entfernt ist
sent❌ NeinE-Mail bereits an Mail-Server übertragen
delivered❌ NeinE-Mail bereits an Empfänger zugestellt
bounced❌ NeinE-Mail bereits verarbeitet
canceled❌ NeinE-Mail bereits storniert

E-Mail erneut senden

Sendet eine E-Mail erneut, die fehlgeschlagen ist, einen Fehler hatte oder zurückgehalten wurde. Dabei wird ein Duplikat der ursprünglichen E-Mail erstellt und erneut versendet. Die neue E-Mail erhält eine eigene ID.

POST/emails/{id}/retry

Pfad-Parameter

idstringRequired

Die E-Mail-ID im Format em_xxx.

const response = await fetch('https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry', {
method: 'POST',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();
<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "cURL-Fehler #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}
import requests

response = requests.post(
'https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)
require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result
package main

import (
"encoding/json"
"fmt"
"net/http"
"strings"
)

func main() {
url := "https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry"

req, _ := http.NewRequest("POST", url, strings.NewReader(""))
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}
use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .post("https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.net.http.HttpRequest.BodyPublishers;

public class RetryEmail {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .POST(BodyPublishers.noBody())
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}
using System;
using System.Net.Http;
using System.Threading.Tasks;

public class RetryEmail
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.PostAsync(
            "https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry", 
            new StringContent(""));
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}
curl -X POST https://api.emailit.com/v2/emails/em_abc123xyz789def456/retry \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"
{
"object": "email",
"id": "em_new789xyz456abc123",
"original_id": "em_abc123xyz789def456",
"status": "pending",
"message": "E-Mail wurde für erneuten Versand in die Warteschlange eingereiht"
}
{
"error": "E-Mail nicht gefunden",
"message": "E-Mail mit ID 'em_abc123' wurde in Ihrem Arbeitsbereich nicht gefunden"
}
{
"error": "E-Mail kann nicht erneut gesendet werden",
"message": "E-Mail kann nicht erneut gesendet werden. Aktueller Status: 'delivered'. Nur E-Mails mit Status 'failed', 'errored' oder 'held' können erneut gesendet werden."
}

Wiederholbare E-Mail-Status

StatusWiederholbar?Hinweise
failed✅ JaE-Mail ist hart zurückgekommen
errored✅ JaFehler bei der E-Mail-Verarbeitung
held✅ JaE-Mail wurde zur Prüfung zurückgehalten
pending❌ NeinE-Mail ist bereits in der Warteschlange
sent❌ NeinE-Mail bereits gesendet
delivered❌ NeinE-Mail bereits zugestellt

Wichtige Hinweise

  • Abrechnung: Erneut gesendete E-Mails werden als neue E-Mails nach den Standardpreisen abgerechnet
  • Neue ID: Die erneut gesendete E-Mail erhält eine neue ID, die ursprüngliche E-Mail bleibt unverändert
  • Ursprungsreferenz: Die Antwort enthält original_id zur Verknüpfung mit der ursprünglichen E-Mail
Lokalisiert durch KI