Az első teljes e-mail API: Hogyan forradalmasította a Forward Email az e-mail-kezelést

TL;DR: Mi építettük a világ első teljes REST API-ját e-mail-kezeléshez, olyan fejlett keresési lehetőségekkel, amelyeket egyetlen más szolgáltatás sem kínál. Míg a Gmail, az Outlook és az Apple az IMAP pokolba vagy sebességkorlátozott API-kba kényszeríti a fejlesztőket, a Forward Email villámgyors CRUD műveleteket biztosít üzenetek, mappák, névjegyek és naptárak számára egy egységes REST felületen keresztül, több mint 15 keresési paraméterrel. Erre vártak az e-mail API-fejlesztők.
Az e-mail API problémája
Az e-mail API-k alapvetően hibásak. Pont.
Minden nagyobb e-mail szolgáltató két szörnyű választási lehetőség egyikébe kényszeríti a fejlesztőket:
- IMAP pokol: Küzdelem egy 30 éves protokollal, amelyet asztali kliensekhez terveztek, nem modern alkalmazásokhoz.
- Megnyomorodott API-k: Sebességkorlátozott, csak olvasható, OAuth-komplex API-k, amelyek nem tudják kezelni a tényleges e-mail adatait.
Az eredmény? A fejlesztők vagy teljesen elhagyják az e-mail integrációt, vagy heteket pazarolnak arra, hogy törékeny, folyamatosan hibás IMAP-burkolókat építsenek.
Warning
A piszkos titok: A legtöbb „e-mail API” csak küldő API. Nem lehet programozottan mappákat rendezni, névjegyeket szinkronizálni vagy naptárakat kezelni egy egyszerű REST felületen keresztül. Eddig.
Amit a fejlesztők valójában mondanak
A frusztráció valós és mindenhol dokumentált:
„Nemrég megpróbáltam integrálni a Gmailt az alkalmazásomba, és túl sok időt töltöttem vele. Úgy döntöttem, hogy nem éri meg támogatni a Gmailt.”
- Hacker News fejlesztő, 147 szavazat
„Minden e-mail API középszerű? Valamilyen módon korlátozottnak vagy korlátozónak tűnnek.”
„Miért kell az e-mail fejlesztésnek pocséknak lennie?”
- Reddit r/webdev, 89 hozzászólás a fejlesztői fájdalomról
„Mi teszi a Gmail API-t hatékonyabbá az IMAP-nál? A Gmail API sokkal hatékonyabbá tételének másik oka az, hogy minden üzenetet csak egyszer kell letöltenie. Az IMAP használatával minden üzenetet le kell tölteni és indexelni kell...”
- Stack Overflow kérdés 47 szavazattal
A bizonyítékok mindenhol ott vannak:
- WordPress SMTP problémák: 631 GitHub-problémák az e-mail kézbesítési hibákról
- Zapier korlátozások: Közösségi panaszok körülbelül 10 e-mail/óra limit és IMAP észlelési hibák
- IMAP API projektek: Több nyílt forráskódú A projektek kifejezetten az "IMAP REST-té konvertálására" szolgál, mert ezt egyetlen szolgáltató sem kínálja.
- Gmail API problémák: Stack Overflow 4847 kérdést tett fel "gmail-api" címkével, gyakori panaszokkal a sebességkorlátokkal és a bonyolultsággal kapcsolatban.
Forradalmi megoldás az e-mail továbbítására
Mi vagyunk az első e-mail szolgáltató, amely teljes körű CRUD műveleteket kínál minden e-mail adathoz egy egységes REST API-n keresztül.
Ez nem csak egy újabb küldő API. Ez teljes programozott kontrollt biztosít a következők felett:
- Üzenetek: Létrehozás, olvasás, frissítés, törlés, keresés, áthelyezés, megjelölés
- Mappák: Teljes IMAP mappakezelés REST végpontokon keresztül
- Névjegyek: CardDAV névjegytárolás és szinkronizálás
- Naptárak: CalDAV naptáresemények és ütemezés
Miért építettük ezt a {#why-we-built-this}}
A probléma: Minden e-mail szolgáltató fekete dobozként kezeli az e-maileket. Küldhetsz e-maileket, esetleg el is olvashatod őket komplex OAuth hitelesítéssel, de az e-mail adataid kezelése nem igazán lehetséges programozottan.
Víziónk: Az e-mail integrálása olyan egyszerű kell, hogy legyen, mint bármely modern API. Nincsenek IMAP könyvtárak. Nincs bonyolult OAuth. Nincsenek rémálmok a sebességkorlátozással kapcsolatban. Csak egyszerű, működő REST végpontok.
Az eredmény: Az első olyan e-mail szolgáltatás, ahol teljes e-mail klienst, CRM-integrációt vagy automatizálási rendszert építhetsz fel pusztán HTTP-kérések használatával.
Egyszerű hitelesítés
Nincs OAuth összetettség. Nincs alkalmazásspecifikus jelszavak. Csak az alias hitelesítő adatai:
curl -u "alias@yourdomain.com:password" \
https://api.forwardemail.net/v1/messages
20 végpont, ami mindent megváltoztat
Üzenetek (5 végpont)
GET /v1/messages
- Üzenetek listázása szűréssel (?folder=
,?is_unread=
,?is_flagged=
)POST /v1/messages
- Új üzenetek küldése közvetlenül a mappákbaGET /v1/messages/:id
- Adott üzenet lekérése teljes metaadataivalPUT /v1/messages/:id
- Üzenet frissítése (jelzők, mappa, olvasási állapot)DELETE /v1/messages/:id
- Üzenet végleges törlése
Mappák (5 végpont)
GET /v1/folders
- Feliratkozási állapotú összes mappa listázásaPOST /v1/folders
- Új mappa létrehozása egyéni tulajdonságokkalGET /v1/folders/:id
- Mappaadatok és üzenetek számának lekérésePUT /v1/folders/:id
- Mappatulajdonságok és előfizetés frissítéseDELETE /v1/folders/:id
- Mappa törlése és üzenetek áthelyezésének kezelése
Kapcsolatok (5 végpont)
GET /v1/contacts
- Kapcsolatok listázása kereséssel és lapozássalPOST /v1/contacts
- Új kapcsolat létrehozása teljes vCard-támogatássalGET /v1/contacts/:id
- Kapcsolat lekérése az összes mezővel és metaadattalPUT /v1/contacts/:id
- Kapcsolati adatok frissítése ETag-érvényesítésselDELETE /v1/contacts/:id
- Kapcsolat törlése kaszkádkezeléssel
Naptárak (5 végpont)
GET /v1/calendars
- Naptáresemények listázása dátumszűrésselPOST /v1/calendars
- Naptáresemény létrehozása résztvevőkkel és ismétlődésselGET /v1/calendars/:id
- Esemény részleteinek lekérése időzóna-kezelésselPUT /v1/calendars/:id
- Esemény frissítése ütközésészlelésselDELETE /v1/calendars/:id
- Esemény törlése résztvevői értesítésekkel
Összetett keresés: Nincs ehhez hasonló szolgáltatás:
A Forward Email az egyetlen e-mail szolgáltatás, amely átfogó, programozott keresést kínál az összes üzenetmezőben REST API-n keresztül.
Míg más szolgáltatók legfeljebb alapvető szűrést kínálnak, mi megépítettük a valaha készült legfejlettebb e-mail kereső API-t. Egyetlen Gmail API, Outlook API vagy más szolgáltatás sem közelíti meg a mi keresési képességeinket.
A Search API környezete hibás
Gmail API keresési korlátai:
- ✅ Csak az alapvető
q
paraméter - ❌ Nincs mezőspecifikus keresés
- ❌ Nincs dátumtartomány-szűrés
- ❌ Nincs méretalapú szűrés
- ❌ Nincs mellékletszűrés
- ❌ A Gmail keresési szintaxisára korlátozva
Az Outlook API keresési korlátai:
- ✅ Alap
$search
paraméter - ❌ Nincs speciális mezőcélzás
- ❌ Nincsenek összetett lekérdezéskombinációk
- ❌ Agresszív sebességkorlátozás
- ❌ Összetett OData szintaxis szükséges
Apple iCloud:
- ❌ Nincs API
- ❌ Csak IMAP keresés (ha működik)
ProtonMail és Tuta:
- ❌ Nincsenek nyilvános API-k
- ❌ Nincsenek programozott keresési lehetőségek
Forward Email keresési API
Több mint 15 keresési paramétert kínálunk, amelyeket más szolgáltatás nem biztosít:
Keresési képesség | E-mail továbbítása | Gmail API | Outlook API | Mások |
---|---|---|---|---|
Mezőspecifikus keresés | ✅ Tárgy, törzs, feladó, címzett, másolat, fejlécek | ❌ | ❌ | ❌ |
Több mezős általános keresés | ✅ ?search= minden mezőben |
✅ Alapvető q= |
✅ Alapvető $search= |
❌ |
Dátumtartomány szűrése | ✅ ?since= & ?before= |
❌ | ❌ | ❌ |
Méretalapú szűrés | ✅ ?min_size= & ?max_size= |
❌ | ❌ | ❌ |
Mellékletszűrés | ✅ ?has_attachments=true/false |
❌ | ❌ | ❌ |
Fejléc keresése | ✅ ?headers=X-Priority |
❌ | ❌ | ❌ |
Üzenetazonosító keresése | ✅ ?message_id=abc123 |
❌ | ❌ | ❌ |
Kombinált szűrők | ✅ Több paraméter ÉS logikával | ❌ | ❌ | ❌ |
Kis- és nagybetűket nem megkülönböztető | ✅ Minden keresés | ✅ | ✅ | ❌ |
Oldalszámozás támogatása | ✅ Minden keresési paraméterrel működik | ✅ | ✅ | ❌ |
Valós keresési példák
Az előző negyedév összes számlájának megkeresése:
# Forward Email - Simple and powerful
GET /v1/messages?subject=invoice&since=2024-01-01T00:00:00Z&before=2024-04-01T00:00:00Z
# Gmail API - Impossible with their limited search
# No date range filtering available
# Outlook API - Complex OData syntax, limited functionality
GET /me/messages?$search="invoice"&$filter=receivedDateTime ge 2024-01-01T00:00:00Z
Nagyméretű mellékletek keresése adott feladótól:
# Forward Email - Comprehensive filtering
GET /v1/messages?from=finance@company.com&has_attachments=true&min_size=1000000
# Gmail API - Cannot filter by size or attachments programmatically
# Outlook API - No size filtering available
# Others - No APIs available
Összetett, többmezős keresés:
# Forward Email - Advanced query capabilities
GET /v1/messages?body=quarterly&from=manager&is_flagged=true&folder=Reports
# Gmail API - Limited to basic text search only
GET /gmail/v1/users/me/messages?q=quarterly
# Outlook API - Basic search without field targeting
GET /me/messages?$search="quarterly"
Teljesítménybeli előnyök
E-mail továbbítási keresési teljesítménye:
- ⚡ 100 ms alatti válaszidők összetett keresésekhez
- 🔍 Reguláris kifejezések optimalizálása megfelelő indexeléssel
- 📊 Párhuzamos lekérdezés-végrehajtás darabszámhoz és adatokhoz
- 💾 Hatékony memória-kihasználás lean lekérdezésekkel
Versenytársi teljesítményproblémák:
- 🐌 Gmail API: A sebesség felhasználónként másodpercenként legfeljebb 250 kvótaegységre korlátozódik.
- 🐌 Outlook API: Agresszív sávszélesség-szabályozás összetett várakozási követelményekkel.
- 🐌 Egyéb: Nincsenek összehasonlítható API-k.
Keresési funkciók, amelyek senki másnak nincsenek
1. Fejlécspecifikus keresés
# Find messages with specific headers
GET /v1/messages?headers=X-Priority:1
GET /v1/messages?headers=X-Spam-Score
2. Méretalapú intelligencia
# Find newsletter emails (typically large)
GET /v1/messages?min_size=50000&from=newsletter
# Find quick replies (typically small)
GET /v1/messages?max_size=1000&to=support
3. Mellékletalapú munkafolyamatok
# Find all documents sent to legal team
GET /v1/messages?to=legal&has_attachments=true&body=contract
# Find emails without attachments for cleanup
GET /v1/messages?has_attachments=false&before=2023-01-01T00:00:00Z
4. Kombinált üzleti logika
# Find urgent flagged messages from VIPs with attachments
GET /v1/messages?is_flagged=true&from=ceo&has_attachments=true&subject=urgent
Miért fontos ez a fejlesztők számára
Olyan alkalmazások készítése, amelyek korábban lehetetlenek voltak:
- Speciális e-mail-analitika: E-mail-minták elemzése méret, feladó és tartalom szerint
- Intelligens e-mail-kezelés: Automatikus rendezés összetett kritériumok alapján
- Megfelelőség és felderítés: Jogi követelményeknek megfelelő e-mailek keresése
- Üzleti intelligencia: Betekintések kinyerése az e-mail-kommunikációs mintákból
- Automatizált munkafolyamatok: Műveletek indítása kifinomult e-mail-szűrők alapján
A technikai megvalósítás
Keresési API-nk a következőket használja:
- Reguláris kifejezések optimalizálása megfelelő indexelési stratégiákkal
- Párhuzamos végrehajtás a teljesítmény érdekében
- Beviteli validáció a biztonság érdekében
- Átfogó hibakezelés a megbízhatóság érdekében
// Example: Complex search implementation
const searchConditions = [];
if (ctx.query.subject) {
searchConditions.push({
subject: { $regex: ctx.query.subject, $options: 'i' }
});
}
if (ctx.query.from) {
searchConditions.push({
$or: [
{ 'from.address': { $regex: ctx.query.from, $options: 'i' } },
{ 'from.name': { $regex: ctx.query.from, $options: 'i' } }
]
});
}
// Combine with AND logic
if (searchConditions.length > 0) {
query.$and = searchConditions;
}
Tip
Fejlesztői előny: A Forward Email keresési API-jával olyan e-mail alkalmazásokat hozhat létre, amelyek funkcionalitásban vetekednek az asztali kliensekkel, miközben megőrzik a REST API-k egyszerűségét.
Villámgyors teljesítményű architektúra
Technikai rendszerünket a sebességre és a megbízhatóságra építettük:
Teljesítmény-összehasonlító tesztek
Miért vagyunk villámgyorsak:
Összetevő | Technológia | Teljesítménynövelő |
---|---|---|
Tárolás | NVMe SSD | 10-szer gyorsabb, mint a hagyományos SATA |
Adatbázis | SQLite + msgpackr | Nulla hálózati késleltetés, optimalizált szerializáció |
Hardver | AMD Ryzen csupasz fém | Nincsenek virtualizációs költségek |
Gyorsítótárolás | Memóriában tárolt + perzisztens | Milliszekundumos válaszidők |
Biztonsági mentések | Cloudflare R2 titkosítva | Vállalati szintű megbízhatóság |
Valós teljesítményadatok:
- API válaszidő: átlagosan < 50 ms
- Üzenet lekérése: < 10 ms gyorsítótárazott üzenetek esetén
- Mappa műveletek: < 5 ms metaadat-műveletek esetén
- Kapcsolat szinkronizálása: 1000+ kapcsolat/másodperc
- Üzemidő: 99,99%-os SLA redundáns infrastruktúrával
Adatvédelem-első architektúra
Nulla tudásalapú tervezés: Csak Ön férhet hozzá az IMAP jelszavával – mi nem tudjuk elolvasni az e-mailjeit. A nulla tudású architektúra jelszavunk teljes adatvédelmet biztosít, miközben kiváló teljesítményt nyújt.
Miért vagyunk mások: Teljes körű összehasonlítás
Főbb szolgáltatói korlátozások
E-mail továbbításának előnyei
Jellemző | E-mail továbbítása | Verseny |
---|---|---|
Teljes CRUD | ✅ Teljes körű létrehozás, olvasás, frissítés és törlés az összes adathoz | ❌ Csak olvasható vagy korlátozott műveletek |
Egységes API | ✅ Üzenetek, mappák, névjegyek, naptárak egyetlen API-ban | ❌ Külön API-k vagy hiányzó funkciók |
Egyszerű hitelesítés | ✅ Alapszintű hitelesítés alias hitelesítő adatokkal | ❌ Komplex OAuth több hatókörrel |
Nincsenek díjkorlátok | ✅ Nagylelkű korlátok valós alkalmazásokhoz tervezve | ❌ Korlátozó kvóták, amelyek megzavarják a munkafolyamatokat |
Saját tárhely | ✅ Complete self-hosting option | ❌ Csak szállítói zárolás |
Magánélet | ✅ Nulla tudás, titkosított, privát | ❌ Adatbányászat és adatvédelmi aggályok |
Teljesítmény | ✅ 50 ms alatti válaszidő, NVMe tárhely | ❌ Hálózati késleltetés, szabályozási késések |
A nyílt forráskódú átláthatósági probléma
A ProtonMail és a Tuta „nyílt forráskódú” és „átlátható” szoftverként reklámozza magát, de ez félrevezető marketing, amely sérti a modern adatvédelmi elveket.
Warning
Hamis átláthatósági állítások: Mind a ProtonMail, mind a Tuta kiemelten reklámozza „nyílt forráskódú” hitelesítő adatait, miközben a legfontosabb szerveroldali kódjukat zártként és titokban tartják.
A ProtonMail megtévesztése:
- Állítások: A "Nyílt forráskódúak vagyunk" kiemelt helyen szerepel a marketingben
- Valóság: A szerverkód teljes mértékben szabadalmaztatott - csak a kliensalkalmazások nyílt forráskódúak
- Hatás: A felhasználók nem tudják ellenőrizni a szerveroldali titkosítást, az adatkezelést vagy az adatvédelmi állításokat
- Átláthatósági irányelvek megsértése: Nincs mód a tényleges e-mail-feldolgozó és -tároló rendszerek auditálására
Tuta félrevezető marketingje:
- Állítások: A "Nyílt forráskódú e-mail", mint alapvető értékesítési pont
- Valóság: A A háttérinfrastruktúra zárt forráskódú – csak a frontend érhető el
- Hatás: A saját fejlesztésű titkosítás megakadályozza a szabványos e-mail protokollok (IMAP/SMTP) használatát
- Rögzítési stratégia: Az egyéni titkosítás kikényszeríti a gyártótól való függőséget
Miért fontos ez a modern adatvédelem szempontjából:
2025-ben a valódi adatvédelem teljes átláthatóságot követel. Amikor az e-mail-szolgáltatók „nyílt forráskódúnak” vallják magukat, de elrejtik a szerverkódjukat:
- Ellenőrizhetetlen titkosítás: Nem auditálható, hogy az adataid hogyan vannak valójában titkosítva.
- Rejtett adatkezelési gyakorlatok: A szerveroldali adatkezelés továbbra is titoktartás alatt áll.
- Bizalomalapú biztonság: Ellenőrzés nélkül meg kell bíznod az állításaikban.
- Beszállítóhoz kötöttség: A saját fejlesztésű rendszerek megakadályozzák az adatok hordozhatóságát.
Az e-mail továbbításának valódi átláthatósága:
- ✅ Teljesen nyílt forráskódú - szerver és kliens kód
- ✅ Saját tárhely elérhető - saját példány futtatása
- ✅ Standard protokollok - IMAP, SMTP, CardDAV, CalDAV kompatibilitás
- ✅ Auditálható biztonság - minden kódsor ellenőrizhető
- ✅ Nincs gyártóhoz kötöttség - az Ön adatai, az Ön irányítása
Tip
A valódi nyílt forráskód azt jelenti, hogy minden állítást ellenőrizhet. A Forward Email segítségével auditálhatja titkosításunkat, áttekintheti adatkezelésünket, sőt akár saját példányt is futtathat. Ez az igazi átláthatóság.
Több mint 30 valós integrációs példa
1. WordPress kapcsolatfelvételi űrlap fejlesztése
Probléma: WordPress SMTP konfigurációs hibák (631 GitHub-problémák) Megoldás: A közvetlen API-integráció teljesen megkerüli a SMTP-t
// WordPress contact form that saves to Sent folder
await fetch('https://api.forwardemail.net/v1/messages', {
method: 'POST',
headers: {
'Authorization': 'Basic ' + btoa('contact@site.com:password'),
'Content-Type': 'application/json'
},
body: JSON.stringify({
to: [{ address: 'owner@site.com' }],
subject: 'Contact Form: ' + formData.subject,
text: formData.message,
folder: 'Sent'
})
});
2. Zapier alternatíva az e-mail automatizáláshoz
Probléma: A Zapier óránként 10 e-mail korláttal rendelkezik és IMAP-észlelési hibák Megoldás: Korlátlan automatizálás teljes e-mail-vezérléssel
// Auto-organize emails by sender domain
const messages = await fetch('/v1/messages?folder=INBOX');
for (const message of messages) {
const domain = message.from.split('@')[1];
await fetch(`/v1/messages/${message.id}`, {
method: 'PUT',
body: JSON.stringify({ folder: `Clients/${domain}` })
});
}
3. CRM e-mail szinkronizálás
Probléma: Manuális kapcsolatkezelés e-mail és CRM rendszerek között Megoldás: Kétirányú szinkronizálás a CardDAV kapcsolat API-val
// Sync new email contacts to CRM
const newContacts = await fetch('/v1/contacts');
for (const contact of newContacts) {
await crmAPI.createContact({
name: contact.name,
email: contact.email,
source: 'email_api'
});
}
4. E-kereskedelmi megrendelések feldolgozása
Probléma: Manuális rendelési e-mail feldolgozás a e-kereskedelmi platformok felhasználóhoz Megoldás: Automatizált rendeléskezelési folyamat
// Process order confirmation emails
const orders = await fetch('/v1/messages?folder=Orders');
const orderEmails = orders.filter(msg =>
msg.subject.includes('Order Confirmation')
);
for (const order of orderEmails) {
const orderData = parseOrderEmail(order.text);
await updateInventory(orderData);
await fetch(`/v1/messages/${order.id}`, {
method: 'PUT',
body: JSON.stringify({ folder: 'Orders/Processed' })
});
}
5. Támogatási jegyek integrációja
Probléma: Az e-mail-szálak szétszórva jelennek meg a ügyfélszolgálati platformok mappában.Megoldás: Teljes körű e-mail-szálkövetés.
// Create support ticket from email thread
const messages = await fetch('/v1/messages?folder=Support');
const supportEmails = messages.filter(msg =>
msg.to.some(addr => addr.includes('support@'))
);
for (const email of supportEmails) {
const ticket = await supportSystem.createTicket({
subject: email.subject,
from: email.from,
body: email.text,
timestamp: email.date
});
}
6. Hírlevélkezelő rendszer
Probléma: Korlátozott hírlevél platform integrációk Megoldás: Teljes körű előfizetői életciklus-kezelés
// Auto-manage newsletter subscriptions
const messages = await fetch('/v1/messages?folder=Newsletter');
const unsubscribes = messages.filter(msg =>
msg.subject.toLowerCase().includes('unsubscribe')
);
for (const msg of unsubscribes) {
await removeSubscriber(msg.from);
await fetch(`/v1/messages/${msg.id}`, {
method: 'PUT',
body: JSON.stringify({ folder: 'Newsletter/Unsubscribed' })
});
}
7. E-mail alapú feladatkezelés
Probléma: A Beérkezett üzenetek túlterheltsége és feladatkövetés Megoldás: E-mailek átalakítása végrehajtható feladatokká
// Create tasks from flagged emails
const messages = await fetch('/v1/messages?is_flagged=true');
for (const email of messages) {
await taskManager.createTask({
title: email.subject,
description: email.text,
assignee: email.to[0].address,
dueDate: extractDueDate(email.text)
});
}
8. Többfiókos e-mail-összesítés
Probléma: több e-mail fiók kezelése több szolgáltató között Megoldás: Egységes postafiók felület
// Aggregate emails from multiple accounts
const accounts = ['work@domain.com', 'personal@domain.com'];
const allMessages = [];
for (const account of accounts) {
const messages = await fetch('/v1/messages', {
headers: { 'Authorization': getAuth(account) }
});
allMessages.push(...messages.map(m => ({ ...m, account })));
}
9. Speciális e-mail-elemzési irányítópult
Probléma: Nincs betekintés a e-mail minták objektumba kifinomult szűréssel Megoldás: Egyéni e-mail elemzések speciális keresési funkciókkal
// Generate comprehensive email analytics using advanced search
const analytics = {};
// Analyze email volume by sender domain
const messages = await fetch('/v1/messages');
analytics.senderDomains = analyzeSenderDomains(messages);
// Find large attachments consuming storage
const largeAttachments = await fetch('/v1/messages?has_attachments=true&min_size=1000000');
analytics.storageHogs = largeAttachments.map(msg => ({
subject: msg.subject,
from: msg.from,
size: msg.size
}));
// Analyze communication patterns with VIPs
const vipEmails = await fetch('/v1/messages?from=ceo@company.com');
const urgentVipEmails = await fetch('/v1/messages?from=ceo@company.com&subject=urgent');
analytics.vipCommunication = {
total: vipEmails.length,
urgent: urgentVipEmails.length,
urgencyRate: (urgentVipEmails.length / vipEmails.length) * 100
};
// Find unread emails by date range for follow-up
const lastWeek = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
const unreadRecent = await fetch(`/v1/messages?is_unread=true&since=${lastWeek}`);
analytics.followUpNeeded = unreadRecent.length;
// Analyze email sizes for optimization
const smallEmails = await fetch('/v1/messages?max_size=1000');
const mediumEmails = await fetch('/v1/messages?min_size=1000&max_size=50000');
const largeEmails = await fetch('/v1/messages?min_size=50000');
analytics.sizeDistribution = {
small: smallEmails.length,
medium: mediumEmails.length,
large: largeEmails.length
};
// Search for compliance-related emails
const complianceEmails = await fetch('/v1/messages?body=confidential&has_attachments=true');
analytics.complianceReview = complianceEmails.length;
10. Intelligens e-mail archiválás
Probléma: Manuális e-mail szervezés Megoldás: Intelligens e-mail kategorizálás
// Auto-archive old emails by category
const messages = await fetch('/v1/messages');
const oldEmails = messages.filter(email =>
isOlderThan(email.date, 90) // 90 days
);
for (const email of oldEmails) {
const category = categorizeEmail(email);
await fetch(`/v1/messages/${email.id}`, {
method: 'PUT',
body: JSON.stringify({ folder: `Archive/${category}` })
});
}
11. E-mail-naptár integráció
Probléma: Manuális naptári esemény létrehozása e-mailekből Megoldás: Automatikus eseménykinyerés és -létrehozás
// Extract meeting details from emails
const messages = await fetch('/v1/messages?folder=Meetings');
const meetingEmails = messages.filter(email =>
email.subject.toLowerCase().includes('meeting')
);
for (const email of meetingEmails) {
const meetingData = extractMeetingInfo(email.text);
if (meetingData.date && meetingData.time) {
await fetch('/v1/calendars', {
method: 'POST',
body: JSON.stringify({
title: email.subject,
start: meetingData.datetime,
attendees: [email.from, ...email.to]
})
});
}
}
12. E-mail biztonsági mentés és megfelelőség
Probléma: E-mail-megőrzés és megfelelőségi követelmények Megoldás: Automatikus biztonsági mentés metaadatok megőrzésével
// Backup emails with full metadata
const allMessages = await fetch('/v1/messages');
const backup = {
timestamp: new Date(),
messages: allMessages.map(msg => ({
id: msg.id,
subject: msg.subject,
from: msg.from,
to: msg.to,
date: msg.date,
flags: msg.flags
}))
};
await saveToComplianceStorage(backup);
13. E-mail alapú tartalomkezelés
Probléma: Tartalombeküldések kezelése e-mailben a CMS platformok felhasználó számára Megoldás: E-mail tartalomkezelő rendszerként
// Process content submissions from email
const messages = await fetch('/v1/messages?folder=Submissions');
const submissions = messages.filter(msg =>
msg.to.some(addr => addr.includes('submit@'))
);
for (const submission of submissions) {
const content = parseSubmission(submission.text);
await cms.createDraft({
title: submission.subject,
content: content.body,
author: submission.from
});
}
14. E-mail sablonok kezelése
Probléma: Inkonzisztens e-mail sablonok a csapaton belül Megoldás: Központosított sablonrendszer API-val
// Send templated emails with dynamic content
const template = await getEmailTemplate('welcome');
await fetch('/v1/messages', {
method: 'POST',
body: JSON.stringify({
to: [{ address: newUser.email }],
subject: template.subject.replace('{{name}}', newUser.name),
html: template.html.replace('{{name}}', newUser.name),
folder: 'Sent'
})
});
15. E-mail-alapú munkafolyamat-automatizálás
Probléma: Manuális jóváhagyási folyamatok e-mailben Megoldás: Automatizált munkafolyamat-eseményindítók
// Process approval emails
const messages = await fetch('/v1/messages?folder=Approvals');
const approvals = messages.filter(msg =>
msg.subject.includes('APPROVAL')
);
for (const approval of approvals) {
const decision = parseApprovalDecision(approval.text);
await workflow.processApproval({
requestId: extractRequestId(approval.subject),
decision: decision,
approver: approval.from
});
}
16. E-mail biztonság figyelése
Probléma: Manuális biztonsági fenyegetések észlelése Megoldás: Automatizált fenyegetéselemzés
// Monitor for suspicious emails
const recentEmails = await fetch('/v1/messages');
for (const email of recentEmails) {
const threatScore = analyzeThreat(email);
if (threatScore > 0.8) {
await fetch(`/v1/messages/${email.id}`, {
method: 'PUT',
body: JSON.stringify({ folder: 'Security/Quarantine' })
});
await alertSecurityTeam(email);
}
}
17. E-mail alapú felmérésgyűjtés
Probléma: Manuális felmérésre adott válasz feldolgozás Megoldás: Automatikus válaszösszesítés
// Collect and process survey responses
const messages = await fetch('/v1/messages?folder=Surveys');
const responses = messages.filter(msg =>
msg.subject.includes('Survey Response')
);
const surveyData = responses.map(email => ({
respondent: email.from,
responses: parseSurveyData(email.text),
timestamp: email.date
}));
await updateSurveyResults(surveyData);
18. E-mail teljesítményfigyelés
Probléma: Nincs rálátás a e-mail kézbesítési teljesítmény elemre Megoldás: Valós idejű e-mail-metrikák
// Monitor email delivery performance
const sentEmails = await fetch('/v1/messages?folder=Sent');
const deliveryStats = {
sent: sentEmails.length,
bounces: await countBounces(),
deliveryRate: calculateDeliveryRate()
};
await updateDashboard(deliveryStats);
19. E-mail alapú érdeklődő minősítése
Probléma: Manuális érdeklődő pontozás az e-mailes interakciókból Megoldás: Automatizált érdeklődő-minősítési folyamat
// Score leads based on email engagement
const prospects = await fetch('/v1/contacts');
for (const prospect of prospects) {
const messages = await fetch('/v1/messages');
const emails = messages.filter(msg =>
msg.from.includes(prospect.email)
);
const score = calculateEngagementScore(emails);
await crm.updateLeadScore(prospect.id, score);
}
20. E-mail alapú projektmenedzsment
Probléma: Projektfrissítések szétszórva az e-mail-szálakban Megoldás: Központosított projektkommunikációs központ
// Extract project updates from emails
const messages = await fetch('/v1/messages?folder=Projects');
const projectEmails = messages.filter(msg =>
msg.subject.includes('Project Update')
);
for (const email of projectEmails) {
const update = parseProjectUpdate(email.text);
await projectManager.addUpdate({
project: update.projectId,
author: email.from,
content: update.content
});
}
21. E-mail alapú készletgazdálkodás
Probléma: Manuális készletfrissítések beszállítói e-mailekből Megoldás: Automatizált készletkövetés e-mail értesítésekből
// Process inventory updates from supplier emails
const messages = await fetch('/v1/messages?folder=Suppliers');
const inventoryEmails = messages.filter(msg =>
msg.subject.includes('Inventory Update') || msg.subject.includes('Stock Alert')
);
for (const email of inventoryEmails) {
const inventoryData = parseInventoryUpdate(email.text);
await inventory.updateStock({
sku: inventoryData.sku,
quantity: inventoryData.quantity,
supplier: email.from,
timestamp: email.date
});
// Move to processed folder
await fetch(`/v1/messages/${email.id}`, {
method: 'PUT',
body: JSON.stringify({ folder: 'Suppliers/Processed' })
});
}
22. E-mail alapú számlafeldolgozás
Probléma: Manuális számlafeldolgozás és könyvelési integráció Megoldás: Automatizált számlakivonatolás és könyvelési rendszer szinkronizálása
// Extract invoice data from email attachments
const messages = await fetch('/v1/messages?folder=Invoices');
const invoiceEmails = messages.filter(msg =>
msg.subject.toLowerCase().includes('invoice') && msg.attachments.length > 0
);
for (const email of invoiceEmails) {
const invoiceData = await extractInvoiceData(email.attachments[0]);
await accounting.createInvoice({
vendor: email.from,
amount: invoiceData.total,
dueDate: invoiceData.dueDate,
items: invoiceData.lineItems
});
// Flag as processed
await fetch(`/v1/messages/${email.id}`, {
method: 'PUT',
body: JSON.stringify({ flags: ['\\Seen', '\\Flagged'] })
});
}
23. E-mail alapú eseményregisztráció
Probléma: Manuális eseményregisztráció feldolgozás e-mail válaszokból Megoldás: Automatizált résztvevőkezelés és naptárintegráció
// Process event registration emails
const messages = await fetch('/v1/messages?folder=Events');
const registrations = messages.filter(msg =>
msg.subject.includes('Registration') || msg.subject.includes('RSVP')
);
for (const registration of registrations) {
const attendeeData = parseRegistration(registration.text);
// Add to attendee list
await events.addAttendee({
event: attendeeData.eventId,
name: attendeeData.name,
email: registration.from,
dietary: attendeeData.dietaryRestrictions
});
// Create calendar event for attendee
await fetch('/v1/calendars', {
method: 'POST',
body: JSON.stringify({
title: attendeeData.eventName,
start: attendeeData.eventDate,
attendees: [registration.from]
})
});
}
24. E-mail alapú dokumentum-jóváhagyási munkafolyamat
Probléma: Komplex dokumentum jóváhagyása láncok e-mailben Megoldás: Automatizált jóváhagyáskövetés és dokumentumverziókezelés
// Track document approval workflow
const messages = await fetch('/v1/messages?folder=Approvals');
const approvalEmails = messages.filter(msg =>
msg.subject.includes('Document Approval')
);
for (const email of approvalEmails) {
const approval = parseApprovalEmail(email.text);
await documentSystem.updateApproval({
documentId: approval.documentId,
approver: email.from,
status: approval.decision, // 'approved', 'rejected', 'needs_changes'
comments: approval.comments,
timestamp: email.date
});
// Check if all approvals complete
const document = await documentSystem.getDocument(approval.documentId);
if (document.allApprovalsComplete) {
await documentSystem.finalizeDocument(approval.documentId);
}
}
25. E-mail alapú ügyfél-visszajelzés elemzés
Probléma: Manuális vásárlói visszajelzések gyűjtés és véleményelemzés Megoldás: Automatizált visszajelzés-feldolgozás és véleménykövetés
// Analyze customer feedback from emails
const messages = await fetch('/v1/messages?folder=Feedback');
const feedbackEmails = messages.filter(msg =>
msg.to.some(addr => addr.includes('feedback@'))
);
for (const email of feedbackEmails) {
const sentiment = await analyzeSentiment(email.text);
const category = categorizeFeeback(email.text);
await feedback.recordFeedback({
customer: email.from,
content: email.text,
sentiment: sentiment.score, // -1 to 1
category: category, // 'bug', 'feature', 'complaint', 'praise'
priority: calculatePriority(sentiment, category),
timestamp: email.date
});
// Auto-escalate negative feedback
if (sentiment.score < -0.5) {
await escalateToSupport(email);
}
}
26. E-mail alapú toborzási folyamat
Probléma: Manuális toborzás és jelöltkövetés Megoldás: Automatizált jelöltkezelés és interjúütemezés
// Process job application emails
const messages = await fetch('/v1/messages?folder=Careers');
const applications = messages.filter(msg =>
msg.subject.toLowerCase().includes('application') && msg.attachments.length > 0
);
for (const application of applications) {
const resume = await parseResume(application.attachments[0]);
const candidate = await ats.createCandidate({
name: resume.name,
email: application.from,
skills: resume.skills,
experience: resume.experience,
position: extractPosition(application.subject)
});
// Auto-schedule screening if qualified
if (candidate.qualificationScore > 0.7) {
await calendar.scheduleInterview({
candidateId: candidate.id,
type: 'phone_screening',
duration: 30
});
}
}
27. E-mail alapú költségjelentés-feldolgozás
Probléma: Manuális költségjelentés beküldés és jóváhagyás Megoldás: Automatizált költségkinyerési és jóváhagyási munkafolyamat
// Process expense report emails
const messages = await fetch('/v1/messages?folder=Expenses');
const expenseEmails = messages.filter(msg =>
msg.subject.includes('Expense') && msg.attachments.length > 0
);
for (const email of expenseEmails) {
const receipts = await processReceipts(email.attachments);
const expenseReport = await expenses.createReport({
employee: email.from,
expenses: receipts.map(receipt => ({
amount: receipt.total,
category: receipt.category,
date: receipt.date,
merchant: receipt.merchant
})),
totalAmount: receipts.reduce((sum, r) => sum + r.total, 0)
});
// Auto-approve small amounts
if (expenseReport.totalAmount < 100) {
await expenses.approve(expenseReport.id);
} else {
await expenses.sendForApproval(expenseReport.id);
}
}
28. E-mail alapú minőségbiztosítási jelentéskészítés
Probléma: Manuális minőségbiztosítás hibakövetés Megoldás: Automatizált QA hibakezelés és hibakövetés
// Process QA bug reports from email
const messages = await fetch('/v1/messages?folder=QA');
const bugReports = messages.filter(msg =>
msg.subject.includes('Bug Report') || msg.subject.includes('QA Issue')
);
for (const report of bugReports) {
const bugData = parseBugReport(report.text);
const ticket = await bugTracker.createIssue({
title: report.subject,
description: bugData.description,
severity: bugData.severity,
steps: bugData.stepsToReproduce,
reporter: report.from,
attachments: report.attachments
});
// Auto-assign based on component
const assignee = await getComponentOwner(bugData.component);
await bugTracker.assign(ticket.id, assignee);
// Create calendar reminder for follow-up
await fetch('/v1/calendars', {
method: 'POST',
body: JSON.stringify({
title: `Follow up on ${ticket.id}`,
start: addDays(new Date(), 3),
attendees: [assignee]
})
});
}
29. E-mail alapú szállítókezelés
Probléma: Manuális szállítói kommunikáció és szerződéskövetés Megoldás: Automatizált szállítói kapcsolatkezelés
// Track vendor communications and contracts
const messages = await fetch('/v1/messages?folder=Vendors');
const vendorEmails = messages.filter(msg =>
isVendorEmail(msg.from)
);
for (const email of vendorEmails) {
const vendor = await vendors.getByEmail(email.from);
// Log communication
await vendors.logCommunication({
vendorId: vendor.id,
type: 'email',
subject: email.subject,
content: email.text,
timestamp: email.date
});
// Check for contract-related keywords
if (email.text.includes('contract') || email.text.includes('renewal')) {
await vendors.flagForContractReview({
vendorId: vendor.id,
emailId: email.id,
priority: 'high'
});
// Create task for procurement team
await tasks.create({
title: `Review contract communication from ${vendor.name}`,
assignee: 'procurement@company.com',
dueDate: addDays(new Date(), 2)
});
}
}
30. E-mail alapú közösségi média figyelés
Probléma: Manuális közösségi média említéskövetés és válasz Megoldás: Automatizált közösségi média riasztásfeldolgozás és válaszkoordináció
// Process social media alerts from email notifications
const messages = await fetch('/v1/messages?folder=Social');
const socialAlerts = messages.filter(msg =>
msg.from.includes('alerts@') || msg.subject.includes('Social Mention')
);
for (const alert of socialAlerts) {
const mention = parseSocialMention(alert.text);
await socialMedia.recordMention({
platform: mention.platform,
author: mention.author,
content: mention.content,
sentiment: mention.sentiment,
reach: mention.followerCount,
url: mention.url
});
// Auto-escalate negative mentions with high reach
if (mention.sentiment < -0.5 && mention.followerCount > 10000) {
await socialMedia.escalateToTeam({
mentionId: mention.id,
priority: 'urgent',
assignee: 'social-media-manager@company.com'
});
// Create calendar reminder for immediate response
await fetch('/v1/calendars', {
method: 'POST',
body: JSON.stringify({
title: `Urgent: Respond to negative social mention`,
start: addMinutes(new Date(), 30),
attendees: ['social-media-manager@company.com']
})
});
}
}
Első lépések
1. Hozza létre továbbított e-mail fiókját
Regisztráljon a forwardemail.net oldalon, és igazolja a domainjét.
2. API hitelesítő adatok generálása
Az alias e-mail címed és jelszavad API hitelesítő adatokként szolgálnak – további beállításra nincs szükség.
3. Első API-hívás végrehajtása
# List your messages
curl -u "your-alias@domain.com:password" \
https://api.forwardemail.net/v1/messages
# Create a new contact
curl -u "your-alias@domain.com:password" \
-X POST \
-H "Content-Type: application/json" \
-d '{"fullName":"John Doe","emails":[{"value":"john@example.com"}]}' \
https://api.forwardemail.net/v1/contacts
4. Tekintse meg a dokumentációt
A teljes API dokumentációért interaktív példákkal ellátogat a forwardemail.net/en/email-api oldalra.
Műszaki források
- Teljes API dokumentáció - Interaktív OpenAPI 3.0 specifikáció
- Saját tárhely útmutató - E-mail továbbításának telepítése az infrastruktúrán
- Biztonsági tanulmány - Műszaki architektúra és biztonsági részletek
- GitHub adattár - Nyílt forráskódú kódbázis
- Fejlesztői támogatás - Közvetlen hozzáférés a mérnöki csapatunkhoz
Készen állsz az e-mail integráció forradalmasítására? Kezdje el az építkezést még ma a Forward Email API-jával és tapasztald meg az első, fejlesztők számára tervezett teljes e-mail-kezelő platformot.
E-mail továbbítása: Az e-mail szolgáltatás, amely végre jól kezeli az API-kat.