LinkedIn
Instagram
WhatsApp
Telegramm
Google Kalender
Slack-Gemeinschaft beitretenE-Mail-API für Entwickler:
Erstellen mit Gmail, Outlook & IMAP
Eine praktische Referenz für Entwickler, die E-Mail-Integrationen erstellen: Vergleichen Sie die Gmail API, Microsoft Graph und IMAP und sehen Sie, wie eine einheitliche E-Mail-API für Entwickler wochenlange Boilerplate in einen einzigen REST-Aufruf umwandelt.
Was ist eine E-Mail-API für Entwickler?
Bevor Sie Anbieter vergleichen und Code schreiben, hier ist die präzise Definition, die Suchmaschinen und Ihre Teamkollegen benötigen.
Eine E-Mail-API für Entwickler ist eine programmatische Schnittstelle, die es Ihrer Anwendung ermöglicht, sich als Benutzer zu authentifizieren und dann die E-Mails dieses Benutzers direkt in Gmail, Outlook oder jeder IMAP-Postfach zu lesen, zu senden oder zu verwalten – ohne jemals deren Passwort zu verarbeiten. Die API authentifiziert über OAuth 2.0 (oder IMAP-Anmeldeinformationen), gibt strukturierte JSON-Antworten zurück und löst Webhooks aus, wenn neue E-Mails eintreffen. Sie unterscheidet sich kategorisch von einer Transaktions-E-Mail-API (SendGrid, Mailgun), die Marketing- oder Benachrichtigungs-E-Mails sendet im Namen Ihrer Marke - eine E-Mail-API für Entwickler fungiert im Auftrag Ihres Benutzers, in ihrem bestehenden Briefkasten.
In der Praxis: Ein SaaS-Helpdesk nutzt eine E-Mail-API, um Support-Tickets direkt aus dem Gmail-Posteingang eines Kunden abzurufen. Ein CRM nutzt sie, um jeden E-Mail-Thread zu synchronisieren, den ein Vertriebsmitarbeiter mit einem Interessenten austauscht. Ein KI-Agent nutzt sie, um Antworten im Outlook-Konto eines Benutzers zu lesen, zu klassifizieren und Entwürfe zu erstellen. Dies sind serverseitige OAuth-Integrationen auf Benutzerebene, keine Pipelines für Massenversendungen.
Warum Entwickler eine E-Mail-API-Integration benötigen
Dies sind die vier Produktkategorien, in denen eine E-Mail-API für Entwickler einen direkten Geschäftswert liefert – das Lesen und Bearbeiten von E-Mails echter Benutzer, nicht das Versenden von Massen-E-Mails.
CRMs, Helpdesks und Projektmanagement-Tools benötigen Live-Zugriff auf das Postfach eines Benutzers. Ihre App authentifiziert sich einmal per OAuth und liest, verarbeitet und zeigt E-Mails dann direkt in Ihrer Benutzeroberfläche an – kein Kopieren und Einfügen, keine Weiterleitungsregeln. Die E-Mail-API-Integration läuft im Hintergrund und hält Ihre Daten aktuell.
LLM-gestützte Agenten müssen E-Mails analysieren und klassifizieren um Antworten zu entwerfen, Entitäten zu extrahieren, Workflows auszulösen oder Tickets weiterzuleiten. Eine E-Mail-API für Entwickler bietet Ihrem KI-Agenten strukturierten JSON-Zugriff auf den Posteingang – Betreff, Body, Anhänge, Header – ohne dass ein benutzerdefinierter Mail-Client erstellt werden muss.
Support-E-Mails abrufen direkt von Kundenpostfächer oder geteilte Posteingänge, taggen Sie sie nach Thema, weisen Sie Agenten zu und posten Sie Antworten – alles programmatisch. Die E-Mail-API-Integration ersetzt brüchiges SMTP-Polling durch eine ordnungsgemäße REST-Schnittstelle und Echtzeit-Webhooks.
Protokollieren Sie jede E-Mail, die ein Vertriebsmitarbeiter sendet oder empfängt, dem richtigen Kontakt oder Geschäft zu. Verfolgen Sie den Status von Öffnungen/Antworten auf Thread-Ebene. Halten Sie Ihr CRM synchron mit echte Gesprächshistorie Reine E-Mail-API-Integration – benutzerseitig, OAuth-basiert, im Namen jedes einzelnen Mitarbeiters, ohne dass Mitarbeiter eine magische Adresse in BCC setzen müssen.
Dies ist NICHT für Transaktions-E-Mails bestimmt. Wenn Ihr Anwendungsfall das Senden von Passwort-Zurücksetzungen, Bestellbestätigungen oder Newslettern von Ihrer eigenen Domain aus ist, handelt es sich um den Transaktionsmarkt (SendGrid, Mailgun, Resend). Die E-Mail-API von Unipile für Entwickler richtet sich an den Markt für Synchronisation/Lesen/Schreiben im Namen des Benutzers: andere Infrastruktur, andere Compliance-Anforderungen, anderes Preismodell.
Gmail API, Microsoft Graph und IMAP im Vergleich
Jede E-Mail-API-Integration beginnt mit einem von drei nativen Anbietern. Hier ist, was jeder von ihnen bietet und wo jeder von ihnen Reibung für Entwickler erzeugt.
| Merkmal | Gmail-API | Microsoft Graph | IMAP | Unipile (vereinheitlicht) |
|---|---|---|---|---|
| Authentifizierungsmethode | OAuth 2.0 | OAuth 2.0 | Passwort / XOAUTH2 | OAuth 2.0 (alle) |
| Webhooks in Echtzeit | Pub/Sub (GCP benötigt) | Abonnements für Diagramme | Nein (IDLE-Polling) | Vereinigter Webhook |
| Antwortformat | Gmail JSON (nicht standardmäßig) | Graph JSON (OData) | RFC 2822 Raw MIME | Vereinheitlichtes JSON-Schema |
| Token aktualisieren | Handbuch (google-auth-library) | Handbuch | K.A. | Verwaltet von Unipile |
| Höchstsätze | 250 Anfragen/Benutzer/Sekunde | 10.000 Anfragen/10 Min | Variiert je nach Server | Abstrahiert + erneut versuchen |
| E-Mail senden | Ja | Ja | Nur SMTP | Ja (alle Anbieter) |
| Anhänge | Erfordert einen zusätzlichen Aufruf | Max 4MB inline | Vollständiger MIME | Vereinheitlichte Anhänge-API |
| Einrichtungszeit (Schätzung) | 1-2 Wochen | 1-2 Wochen | 3-5 Tage | Stunden |
native E-Mail-API vs. vereinheitlichte E-Mail-API: Codevergleich in der Praxis
Wenn man beide Ansätze nebeneinander – in tatsächlichem Code – sieht, wird der Kompromiss greifbar. Wählen Sie unten eine Sprache aus, um das Lesen von E-Mails nativ im Vergleich über die einheitliche E-Mail-API von Unipile zu vergleichen.
// 1. OAuth-Client installieren und konfigurieren
const {google} = require('googleapis');
const Auth = new google.auth.OAuth2(
CLIENT_ID, CLIENT_SECRET, REDIRECT_URI
);
// 2. Auth-Code gegen Tokens tauschen
const {Tokens} = await auth.Token abrufen(Code);
auth.Anmeldedaten festlegen(Token);
// 3. Speichern & Aktualisieren von Tokens manuell
// 4. Gmail API aufrufen
const gmail = Google.gmail({
Version: 'v1', auth
});
const res = await
gmail.users.messages.list({
userId: ich, maxErgebnisse: 10
});
// 5. Vollständige Nachricht anhand der ID abrufen
const Nachricht = await
gmail.users.messages.bekommen.({
userId: ich,
id: res.data.nachrichten[0].id,
Format 'vollständig'
});
// 6. Payload selbst als base64url dekodierenEines SDK, alle Anbieter
const unipile =
require('@unipile/node-sdk');
const client =
new einspurig.UnipileClient(
API_URL, ACCESS_TOKEN
);
// 2. Von Unipile verwaltete Tokens
// Kein manueller OAuth-Flow erforderlich
// 3. E-Mails auflisten
const Emails = await
client.email.alleAuflisten({
konto_id: ACCOUNT_ID,
Grenze: 10
});
// 4. Körper bereits dekodiert
// Einheitliches JSON - gleiches Schema
// für Gmail, Outlook, IMAP
Konsole.log(E-Mails.Elemente);import msal, Anfragen
# 1. Vertraulicher Kunde von MSAL
app = msal.VertraulicheClientAnwendung(
CLIENT_ID,
Autorität=BEHÖRDE,
client_credential=CLIENT_SECRET
)
# 2. Token im Namen des Benutzers abrufen
Ergebnis = App.acquire_token_by_auth_code_flow(
Fluss, auth_response
)
Token = Ergebnis['Zugriffstoken']
# 3. Token-Aktualisierung durchführen, sicher speichern
# 4. Call-Graph-API
Kopfzeilen = {'Authorization': f'Bearer {token}'}
r = Anfragen.bekommen.(
'https://graph.microsoft.com/v1.0/me/messages',
Kopfzeilen=Kopfzeilen
)
# 5. OData-Envelope-Antwort analysierenimport Anfragen
#-Token, verwaltet von Unipile
# Kein MSAL, keine OAuth-Konfiguration
Kopfzeilen = {
'X-API-KEY': ACCESS_TOKEN,
'Akzeptieren': 'application/json'
}
# funktioniert sowohl mit Gmail als auch mit Outlook
# Gleicher Endpunkt, gleiches Schema
r = Anfragen.bekommen.(
'https://api7.unipile.com:13091'
'/api/v1/emails',
Kopfzeilen=Kopfzeilen,
Parameter={
'Konto-ID': KONTO_ID,
'Grenze': 10
}
)
Emails = r.json()
# Bereits geparst, kein OData# IMAP verfügt über keine REST-API
# Es muss „imaplib“ oder „node-imap“ verwendet werden
# Kein cURL-Äquivalent
#-Beispiel: openssl s_client
# (nur für Debugging – nicht für den Produktivbetrieb)
openssl s_client \
-verbinde imap.gmail.com:993 \
ruhig
# Dann sende die IMAP-Befehle im Rohformat:
# A001 LOGIN user@gmail.com Passwort
# A002 Posteingang auswählen
# A003 FETCH 1 RFC822
# A004 ABMELDEN
# Sie erhalten RFC 2822-MIME im Rohformat
# Muss Header analysieren, dekodieren
# Base64-Teile, Verarbeitung von Mehrteil-Nachrichten
# – Setze dir selbst Grenzen
# Außerdem: keine Webhooks, muss per IDLE-Abfrage erfolgen# REST-API – funktioniert mit jedem
#-E-Mail-Anbieter über cURL
locken. \
-X GET \
-H "X-API-KEY: $TOKEN" \
-H "Annehmen: Anwendung/JSON" \
"https://api7.unipile.com:13091
/api/v1/emails
?account_id=$ACCOUNT_ID
&limit=10"
#-Antwort: sauberes JSON
# { "items": [ { "id": "...",
# "Betreff": "Hallo",
# "from": { "name": "Alice",
# "address": "..." },
# "body_plain": "...",
# "date": "2026-05-12T..." } ] }
# Gleicher Endpunkt für Gmail,
# Outlook und IMAP-KontenOAuth 2.0 Grundlagen für die E-Mail-API-Integration
Jede Produktions-E-Mail-API-Integration setzt auf OAuth 2.0, um sich als Benutzer zu authentifizieren, ohne dessen Passwort zu speichern. Hier erfahren Sie, was Sie für jeden Anbieter einrichten müssen – und wie Unipile dies für Sie übernimmt.
gmail.readonly, Gmail senden. Sensible Scopes erfordern eine Google-Verifizierung für die Produktion.google-auth-bibliothek oder ein benutzerdefinierter Handler.
Mail.Lesen, Mail.Senden, Mail.ReadWrite.SDKs und Tools für die E-Mail-API-Integration
Ob Sie nativ entwickeln oder eine einheitliche Schicht verwenden, das richtige SDK reduziert den Boilerplate-Code. Hier ist die aktuelle Landschaft für jeden Anbieter und für Unipile.
Offizielles SDK für die Unipile Unified Email API. Deckt das Lesen und Senden von E-Mails, die Kontenverwaltung und Webhooks für Gmail, Outlook und IMAP in einem Paket ab. TypeScript-Definitionen inklusive.
@azure/msal-node trennen). Gut instand gehalten. Das OData-Antwortformat erfordert für einfache Anwendungsfälle eine zusätzliche Verarbeitung.Entwicklerfreundliche Preise: Kostenlos starten, transparent skalieren
"Kostenlose" native E-Mail-APIs sind nicht wirklich kostenlos. Die Gmail-API und Microsoft Graph kosten null Dollar pro API-Aufruf, aber jede erfordert wochenlange Entwicklungsarbeit: OAuth-Verifizierungszyklen, Token-Aktualisierungslogik, Webhook-Infrastruktur, Wiederholungsbehandlungsroutinen, Fehlerzuordnung. Ein mittelgroßes Team benötigt in der Regel 3 bis 6 Wochen, bevor es eine einzige Funktion bereitstellen kann. Die vereinheitlichte E-Mail-API von Unipile für Entwickler ersetzt diese Arbeit durch eine 7-tägige kostenlose Testversion, keine Kreditkarte erforderlich.
Fazit: Die API-Aufrufe sind kostenlos, die Ingenieursarbeit nicht. Das Erstellen einer produktionsreifen E-Mail-Integration auf Basis nativer APIs (Authentifizierungsabläufe, Token-Aktualisierung, Fehlerbehandlung, Webhook-Infrastruktur, Multi-Provider-Abstraktion) kostet in der Regel 3 bis 8 Wochen Entwicklerzeit pro Anbieter plus laufende Wartung, wann immer Google oder Microsoft eine Änderung vornehmen, die zu Fehlern führt. Unipile berechnet pro verknügtem Konto und Monat mit transparenten Stufen. Siehe Kostenloser Leitfaden zur E-Mail-API Für die vollständige Aufschlüsselung.
Sicherheit und Compliance für E-Mail-API-Integrationen
Wenn Ihre Anwendung Benutzer-E-Mails verarbeitet, ist Compliance keine Option. Unipile ist für die beiden Frameworks konzipiert, die für Entwickler-orientierte Produkte, die europäische und Unternehmensdaten verarbeiten, relevant sind.
Unipile ist SOC 2 Typ II zertifiziert. Die Prüfung umfasst die Vertrauensdienstkriterien Sicherheit, Verfügbarkeit und Vertraulichkeit. Das bedeutet, dass unabhängige Prüfer die Kontrollen von Unipile über einen längeren Zeitraum – nicht nur zu einem bestimmten Zeitpunkt – verifiziert haben. Erforderlich für die meisten Unternehmenskäufer und SaaS-Sicherheitsfragebögen.
Unipile verarbeitet E-Mail-Daten als ein Datenverarbeiter Gemäß DSGVO Artikel 28 sind Datenverarbeitungsvereinbarungen (DVAs) für alle kostenpflichtigen Tarife verfügbar. Benutzer-E-Mail-Daten werden nur für die Dauer der authentifizierten Sitzung und im Rahmen der vom Benutzer erteilten OAuth-Zustimmung verarbeitet. Keine parallele Speicherung, keine Datenverkäufe an Dritte.
Häufige Fallstricke bei der E-Mail-API-Integration (und wie man sie behebt)
Jeder Entwickler, der seine erste E-Mail-API-Integration erstellt, stößt auf dieselben vier Hindernisse. Hier sind sie – und wie man jedes davon richtig bewältigt.
Das 250-Quota-Einheiten-pro-Benutzer-pro-Sekunde-Limit von Gmail klingt großzügig, bis man feststellt, dass das Auflisten von 10 Nachrichten jeweils 5-10 Einheiten kostet und das Abrufen vollständiger E-Mail-Inhalte pro Byte weitere Kontingente kostet. Microsoft Graph begrenzt sich auf 10.000 Anfragen pro 10 Minuten pro App pro Mandant. Das Erreichen des Limits gibt die Antwort 429 - Too Many Requests zurück. Ohne Wiederholungslogik stürzt deine Synchronisierungsschleife stillschweigend ab.
Google-Zugriffstoken laufen nach 3.600 Sekunden ab. Microsoft-Token nach 60-90 Minuten. Wenn dein Aktualisierungstoken widerrufen wird (Wenn der Nutzer sein Passwort ändert, den App-Zugriff widerruft oder das Token bei Google seit 6 Monaten nicht mehr verwendet wurde), wird die gesamte Synchronisierung stillschweigend beendet. Es wird kein Fehler angezeigt, es sei denn, Sie überwachen die Antwort auf den Aktualisierungsaufruf.
Microsoft Graph-Abonnements laufen nach maximal 4.230 Minuten (~3 Tage für E-Mail) ab. Das Vergessen der Verlängerung bedeutet keine Push-Benachrichtigungen mehr - Ihre App greift auf Polling zurück oder verpasst Ereignisse vollständig. Gmail Pub/Sub-Abonnements sind beständiger, erfordern jedoch ein GCP-Abonnement, um gültig zu bleiben, und das Thema muss vorhanden sein.
E-Mail-APIs sind letztendlich konsistent. Sollte Ihr Synchronisierungsprozess während der Ausführung abstürzen, kann es sein, dass E-Mails duplizieren, eine Seite mit Ergebnissen überspringen oder Löschungen verpassen. Gmail verwendet „historyId“ für die inkrementelle Synchronisierung; Microsoft Graph verwendet „deltaToken“. Beide erfordern eine sorgfältige Cursor-Verwaltung über Neustarts hinweg. IMAP verfügt über keinen nativen Synchronisierungsstatus – Sie müssen Ihre eigene UID-Verfolgung vornehmen.
E-Mail-API für Entwickler – Häufig gestellte Fragen
Antworten auf die häufigsten Fragen von Entwicklern bei der ersten Integration einer E-Mail-API über Gmail, Outlook und IMAP.
npm install @unipile/node-sdk. Und erstellen Sie dann einen Client mit Ihrer API-URL und Ihrem Zugriffstoken und rufen Sie client.email.listAll() um E-Mails zu lesen oder client.email.sende() versenden – über Gmail, Outlook und IMAP mit einem einzigen Code-Pfad. Für native Gmail verwenden Sie googleapis npm-Paket. Für Microsoft Graph verwende @microsoft/microsoft-graph-client.
DE 
EN 
FR 
ES 
IT 
BR 
NL 
PL 
TR