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

Röviden: Megalkottuk a világ első teljes körű REST API-ját e-mail kezeléshez, fejlett keresési lehetőségekkel, amelyeket más szolgáltatás nem kínál. Míg a Gmail, Outlook és Apple az IMAP poklába vagy korlá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 interfészen keresztül, több mint 15 keresési paraméterrel. Ez az az e-mail API, amire a fejlesztők vártak.

Az Email API Probléma

Az email API-k alapvetően hibásak. Pont.

Minden nagy email szolgáltató két szörnyű választás egyikére kényszeríti a fejlesztőket:

  1. IMAP Pokol: Egy 30 éves protokollal küzdeni, amely asztali kliensekhez készült, nem modern alkalmazásokhoz
  2. Megnyomorított API-k: Korlátozott, csak olvasható, OAuth-komplex API-k, amelyek nem tudják kezelni a tényleges email adataidat

Az eredmény? A fejlesztők vagy teljesen feladják az email integrációt, vagy heteket pazarolnak törékeny IMAP csomagolók építésére, amelyek folyamatosan elromlanak.

Warning

A piszkos titok: A legtöbb "email API" valójában csak küldő API. Nem tudsz programozottan mappákat rendezni, névjegyeket szinkronizálni vagy naptárakat kezelni egy egyszerű REST interfészen keresztül. Egészen mostanáig.

Amit a Fejlesztők Valójában Mondanak

A frusztráció valós és mindenhol dokumentált:

"Nemrég próbáltam integrálni a Gmailt az alkalmazásomba, és túl sok időt öntöttem bele. Úgy döntöttem, nem éri meg támogatni a Gmailt."

- Hacker News fejlesztő, 147 szavazat

"Minden email API középszerű? Úgy tűnik, valamilyen módon korlátozottak vagy restriktívek."

- Reddit r/SaaS beszélgetés

"Miért kell az email fejlesztésnek szívásnak lennie?"

- Reddit r/webdev, 89 hozzászólás fejlesztői fájdalomról

"Mi teszi a Gmail API-t hatékonyabbá az IMAP-nál? Egy másik ok, amiért a Gmail API sokkal hatékonyabb, hogy csak egyszer kell letölteni minden üzenetet. IMAP esetén minden üzenetet le kell tölteni és indexelni..."

- Stack Overflow kérdés 47 szavazattal

A bizonyíték mindenhol ott van:

  • WordPress SMTP problémák: 631 GitHub issue az email kézbesítési hibákról
  • Zapier korlátok: Közösségi panaszok 10 email/óra limitről és IMAP felismerési hibákról
  • IMAP API projektek: Több nyílt forráskódú projekt létezik kifejezetten az "IMAP REST-re konvertálására", mert ezt egyetlen szolgáltató sem kínálja
  • Gmail API frusztrációk: A Stack Overflow 4,847 "gmail-api" címkével ellátott kérdése gyakori panaszokkal a korlátozásokról és a komplexitásról

A Forward Email Forradalmi Megoldása

Mi vagyunk az első email szolgáltatás, amely teljes CRUD műveleteket kínál az összes email adatodra egy egységes REST API-n keresztül.

Ez nem csak egy újabb küldő API. Ez teljes programozott irányítás a következő felett:

  • Üzenetek: Létrehozás, olvasás, frissítés, törlés, keresés, mozgatás, megjelölés
  • Mappák: Teljes IMAP mappa kezelés REST végpontokon keresztül
  • Névjegyek: CardDAV névjegy tárolás és szinkronizáció
  • Naptárak: CalDAV naptár események és ütemezés

Miért Építettük Ezt

A Probléma: Minden email szolgáltató fekete dobozként kezeli az emailt. Tudsz emailt küldeni, talán olvasni bonyolult OAuth-pal, de nem tudod igazán kezelni az email adataidat programozottan.

A Látomásunk: Az email integráció legyen olyan egyszerű, mint bármely modern API. Nincs IMAP könyvtár. Nincs OAuth komplexitás. Nincsenek korlátozási rémálmok. Csak egyszerű REST végpontok, amelyek működnek.

Az Eredmény: Az első email szolgáltatás, ahol teljes email klienst, CRM integrációt vagy automatizációs rendszert építhetsz kizárólag HTTP kérésekkel.

Egyszerű Hitelesítés

Nincs OAuth komplexitás. Nincsenek alkalmazás-specifikus jelszavak. Csak az alias hitelesítő adataid:

curl -u "[email protected]:password" \
  https://api.forwardemail.net/v1/messages

20 Végpont, Ami Minden 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 mappákba
  • GET /v1/messages/:id - Egy adott üzenet lekérése teljes metaadatokkal
  • PUT /v1/messages/:id - Üzenet frissítése (jelölők, mappa, olvasottság)
  • DELETE /v1/messages/:id - Üzenet végleges törlése

Mappák (5 végpont)

  • GET /v1/folders - Mappák listázása előfizetési státusszal
  • POST /v1/folders - Új mappa létrehozása egyedi tulajdonságokkal
  • GET /v1/folders/:id - Mappa részleteinek és üzenetszámok lekérése
  • PUT /v1/folders/:id - Mappa tulajdonságainak és előfizetésének frissítése
  • DELETE /v1/folders/:id - Mappa törlése és az üzenetek áthelyezésének kezelése

Kapcsolatok (5 végpont)

  • GET /v1/contacts - Kapcsolatok listázása kereséssel és lapozással
  • POST /v1/contacts - Új kapcsolat létrehozása teljes vCard támogatással
  • GET /v1/contacts/:id - Kapcsolat lekérése minden mezővel és metaadattal
  • PUT /v1/contacts/:id - Kapcsolati adatok frissítése ETag érvényesítéssel
  • DELETE /v1/contacts/:id - Kapcsolat törlése kaszkád kezeléssel

Naptárak (5 végpont)

  • GET /v1/calendars - Naptári események listázása dátumszűréssel
  • POST /v1/calendars - Naptári esemény létrehozása résztvevőkkel és ismétlődéssel
  • GET /v1/calendars/:id - Esemény részleteinek lekérése időzóna kezeléssel
  • PUT /v1/calendars/:id - Esemény frissítése ütközésészleléssel
  • DELETE /v1/calendars/:id - Esemény törlése résztvevő értesítésekkel

Fejlett Keresés: Egyik Szolgáltatás Sem Érhet Hozzánk

A Forward Email az egyetlen e-mail szolgáltatás, amely átfogó, programozható keresést kínál az összes üzenetmezőn keresztül REST API-n.

Míg más szolgáltatók legfeljebb alap szűrést kínálnak, mi építettük a valaha volt legfejlettebb e-mail kereső API-t. Sem a Gmail API, sem az Outlook API, sem más szolgáltatás nem ér fel a keresési képességeinkhez.

A Kereső API Helyzete Szétesett

Gmail API Keresési Korlátozások:

  • ✅ Csak alap q paraméter
  • ❌ Nincs mezőspecifikus keresés
  • ❌ Nincs dátumtartomány szűrés
  • ❌ Nincs méret alapú szűrés
  • ❌ Nincs csatolmány szűrés
  • ❌ Csak a Gmail keresési szintaxis korlátozott használata

Outlook API Keresési Korlátozások:

  • ✅ Alap $search paraméter
  • ❌ Nincs fejlett mezőcélzás
  • ❌ Nincs összetett lekérdezés kombináció
  • ❌ Aggresszív sebességkorlátozás
  • ❌ Bonyolult OData szintaxis szükséges

Apple iCloud:

  • ❌ Egyáltalán nincs API
  • ❌ Csak IMAP keresés (ha működésre bírja az ember)

ProtonMail & Tuta:

  • ❌ Nincs nyilvános API
  • ❌ Nincs programozható keresési lehetőség

A Forward Email Forradalmi Kereső API-ja

15+ keresési paramétert kínálunk, amit más szolgáltatás nem nyújt:

Keresési Képesség Forward Email Gmail API Outlook API Egyéb
Mezőspecifikus Keresés ✅ Tárgy, törzs, feladó, címzett, másolat, fejléc ❌ ❌ ❌
Többmezős Általános Keresés ✅ ?search= az összes mezőn át ✅ Alap q= ✅ Alap $search= ❌
Dátumtartomány Szűrés ✅ ?since= & ?before= ❌ ❌ ❌
Méret Alapú Szűrés ✅ ?min_size= & ?max_size= ❌ ❌ ❌
Csatolmány Szűrés ✅ ?has_attachments=true/false ❌ ❌ ❌
Fejléc Keresés ✅ ?headers=X-Priority ❌ ❌ ❌
Üzenetazonosító Keresés ✅ ?message_id=abc123 ❌ ❌ ❌
Összetett Szűrők ✅ Több paraméter AND logikával ❌ ❌ ❌
Nagybetű-Kisbetű Érzéketlen ✅ Minden keresés ✅ ✅ ❌
Lapozás Támogatás ✅ Minden keresési paraméterrel működik ✅ ✅ ❌

Valós Példák Keresésre

Az elmúlt negyedév összes számlájának megtalálása:

# Forward Email - Egyszerű és hatékony
GET /v1/messages?subject=invoice&since=2024-01-01T00:00:00Z&before=2024-04-01T00:00:00Z

# Gmail API - Lehetetlen a korlátozott keresési lehetőségeik miatt
# Nincs elérhető dátumtartomány szűrés

# Outlook API - Bonyolult OData szintaxis, korlátozott funkcionalitás
GET /me/messages?$search="invoice"&$filter=receivedDateTime ge 2024-01-01T00:00:00Z

Nagy méretű csatolmányok keresése adott feladótól:

# Forward Email - Átfogó szűrés
GET /v1/[email protected]&has_attachments=true&min_size=1000000

# Gmail API - Nem lehet programozottan méret vagy csatolmány alapján szűrni
# Outlook API - Nincs méret szerinti szűrés
# Egyéb - Nincs elérhető API

Összetett, több mezős keresés:

# Forward Email - Fejlett lekérdezési képességek
GET /v1/messages?body=quarterly&from=manager&is_flagged=true&folder=Reports

# Gmail API - Csak alap szöveges keresés lehetséges
GET /gmail/v1/users/me/messages?q=quarterly

# Outlook API - Alap keresés mezőcélzás nélkül
GET /me/messages?$search="quarterly"

Teljesítmény Előnyök

Forward Email keresési teljesítmény:

  • ⚡ 100 ms alatti válaszidők összetett kereséseknél
  • 🔍 Regex optimalizáció megfelelő indexeléssel
  • 📊 Párhuzamos lekérdezés végrehajtás számláláshoz és adatokhoz
  • 💾 Hatékony memóriahasználat karcsú lekérdezésekkel

Versenytársak teljesítményproblémái:

  • 🐌 Gmail API: Felhasználónként másodpercenként 250 kvótaegységre korlátozva
  • 🐌 Outlook API: Aggresszív korlátozás, bonyolult visszalépési szabályokkal
  • 🐌 Egyéb: Nincs összehasonlítható API

Egyedi Keresési Funkciók, Amik Másnak Nincsenek

# Üzenetek keresése adott fejléc alapján
GET /v1/messages?headers=X-Priority:1
GET /v1/messages?headers=X-Spam-Score

2. Méret alapú intelligencia

# Hírlevelek keresése (általában nagy méretűek)
GET /v1/messages?min_size=50000&from=newsletter

# Gyors válaszok keresése (általában kicsik)
GET /v1/messages?max_size=1000&to=support

3. Csatolmány-alapú munkafolyamatok

# Minden dokumentum keresése, amit a jogi csapatnak küldtek
GET /v1/messages?to=legal&has_attachments=true&body=contract

# Csatolmány nélküli emailek keresése takarításhoz
GET /v1/messages?has_attachments=false&before=2023-01-01T00:00:00Z

4. Kombinált üzleti logika

# Sürgős, megjelölt üzenetek keresése VIP feladóktól csatolmányokkal
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 építése, amik korábban lehetetlenek voltak:

  1. Fejlett email elemzés: Email minták elemzése méret, feladó, tartalom alapján
  2. Intelligens email kezelés: Automatikus rendszerezés összetett feltételek alapján
  3. Megfelelőség és feltárás: Specifikus emailek megtalálása jogi követelményekhez
  4. Üzleti intelligencia: Információk kinyerése email kommunikációs mintákból
  5. Automatizált munkafolyamatok: Műveletek indítása kifinomult email szűrők alapján

A Technikai Megvalósítás

Keresési API-nk használja:

  • Regex optimalizációt megfelelő indexelési stratégiákkal
  • Párhuzamos végrehajtást a teljesítményért
  • Bemeneti érvényesítést a biztonságért
  • Átfogó hibakezelést a megbízhatóságért
// Példa: Összetett keresés megvalósítása
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' } }
    ]
  });
}

// Kombinálás ÉS logikával
if (searchConditions.length > 0) {
  query.$and = searchConditions;
}

Tip

Fejlesztői előny: A Forward Email keresési API-jával olyan email alkalmazásokat építhetsz, 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

Műszaki stackünk a sebességre és megbízhatóságra épül:

Teljesítmény Referenciák

Miért vagyunk villámgyorsak:

Összetevő Technológia Teljesítmény Előny
Tárolás NVMe SSD 10x gyorsabb, mint a hagyományos SATA
Adatbázis SQLite + msgpackr Nulla hálózati késleltetés, optimalizált sorosítás
Hardver AMD Ryzen natív Nincs virtualizációs többletterhelés
Gyorsítótár Memóriában + perzisztens Szubmilliszekundumos válaszidők
Biztonsági mentések Cloudflare R2 titkosított Vállalati szintű megbízhatóság

Valódi Teljesítmény Számok:

  • API válaszidő: < 50ms átlag
  • Üzenet lekérés: < 10ms gyorsítótárazott üzeneteknél
  • Mappaműveletek: < 5ms metaadat műveleteknél
  • Kapcsolat szinkronizálás: 1000+ kapcsolat/másodperc
  • Üzemidő: 99,99% SLA redundáns infrastruktúrával

Adatvédelmi Központú Architektúra

Zero-Knowledge Tervezés: Csak Ön fér hozzá az IMAP jelszavával – mi nem olvassuk az e-mailjeit. A zero-knowledge architektúránk teljes adatvédelmet biztosít, miközben villámgyors teljesítményt nyújt.

Miért Vagyunk Mások: Teljes Összehasonlítás

Fő Szolgáltató Korlátozások

Szolgáltató Fő Problémák Specifikus Korlátozások
Gmail API Csak olvasható, Bonyolult OAuth, Külön API-k • Nem lehet módosítani meglévő üzeneteket
• Címkék ≠ mappák
• 1 milliárd kvóta egység/nap limit
• Külön API-k szükségesek névjegyek/naptár kezeléséhez
Outlook API Elavult, Zavaros, Vállalati fókuszú • REST végpontok 2024 márciusában elavultak
• Több zavaró API (EWS, Graph, REST)
• Microsoft Graph bonyolultság
• Aggresszív korlátozások
Apple iCloud Nincs nyilvános API • Egyáltalán nincs nyilvános API
• Csak IMAP, napi 1000 e-mail limit
• Alkalmazás-specifikus jelszavak szükségesek
• 500 címzett üzenetenkénti limit
ProtonMail Nincs API, Hamis nyílt forráskód állítások • Nincs elérhető nyilvános API
• Bridge szoftver szükséges az IMAP hozzáféréshez
• Állítják, hogy "nyílt forráskódú", de a szerver kód zárt
• Csak fizetős csomagokhoz elérhető
Tuta Nincs API, Félrevezető átláthatóság • Nincs REST API e-mail kezeléshez
• Állítják, hogy "nyílt forráskódú", de a backend zárt
• IMAP/SMTP nem támogatott
• Saját titkosítás akadályozza a szabványos integrációkat
Zapier Email Súlyos Korlátozások a Sebességben • Óránként 10 e-mail limit
• Nincs IMAP mappa hozzáférés
• Korlátozott elemzési képességek

Előnyök az Email Továbbításban

Jellemző Email Továbbítás Versenytársak
Teljes CRUD ✅ Teljes létrehozás, olvasás, frissítés, törlés minden adat esetén ❌ Csak olvasás vagy korlátozott műveletek
Egységes API ✅ Üzenetek, mappák, névjegyek, naptárak egy API-ban ❌ Külön API-k vagy hiányzó funkciók
Egyszerű hitelesítés ✅ Alap hitelesítés alias hitelesítő adatokkal ❌ Bonyolult OAuth több jogosultsággal
Nincs korlátozás ✅ Nagylelkű korlátok, valós alkalmazásokhoz tervezve ❌ Korlátozó kvóták, amelyek megszakítják a munkafolyamatokat
Ön-tárhely ✅ Teljes ön-tárhely opció ❌ Csak szolgáltatófüggőség
Adatvédelem ✅ 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árolás ❌ Hálózati késleltetés, korlátozások

Az Nyílt Forráskódú Átláthatóság Problémája

A ProtonMail és a Tuta "nyílt forráskódúként" és "átláthatóként" hirdetik magukat, 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 hangsúlyosan hirdeti "nyílt forráskódú" hitelességét, miközben legkritikusabb szerveroldali kódjuk zárt és tulajdonosi.

A ProtonMail megtévesztése:

  • Állítások: "Mi nyílt forráskódúak vagyunk" kiemelten a marketingben
  • Valóság: A szerverkód teljesen tulajdonosi – csak a kliensalkalmazások nyílt forráskódúak
  • Hatás: A felhasználók nem ellenőrizhetik a szerveroldali titkosítást, adatkezelést vagy adatvédelmi állításokat
  • Átláthatósági megsértés: Nincs mód az e-mail feldolgozó és tároló rendszerek auditálására

A Tuta félrevezető marketingje:

Miért fontos ez a modern adatvédelem szempontjából:

2025-ben az igazi adatvédelem teljes átláthatóságot követel meg. Amikor az e-mail szolgáltatók "nyílt forráskódúnak" mondják magukat, de elrejtik a szerverkódot:

  1. Ellenőrizhetetlen titkosítás: Nem auditálhatod, hogyan titkosítják az adataidat
  2. Rejtett adatkezelési gyakorlatok: A szerveroldali adatkezelés fekete doboz marad
  3. Bizalmi alapú biztonság: Hitelnélküli állításokat kell elfogadnod
  4. Szolgáltatófüggőség: A tulajdonosi rendszerek megakadályozzák az adathordozhatóságot

A Forward Email valódi átláthatósága:

  • ✅ Teljes nyílt forráskód – szerver és kliens kód
  • ✅ Ön-tárhely elérhető – saját példány futtatása
  • ✅ Szabványos protokollok – IMAP, SMTP, CardDAV, CalDAV kompatibilitás
  • ✅ Auditálható biztonság – minden kódsor ellenőrizhető
  • ✅ Nincs szolgáltatófüggőség – a te adataid, a te irányításod

Tip

Az igazi nyílt forráskód azt jelenti, hogy minden állítást ellenőrizhetsz. A Forward Email-lel auditálhatod a titkosításunkat, áttekintheted az adatkezelést, és akár saját példányt is futtathatsz. Ez az igazi átláthatóság.

Több mint 30 valós integrációs példa

1. WordPress Kapcsolati Űrlap Fejlesztés

Probléma: WordPress SMTP konfigurációs hibák (631 GitHub probléma) Megoldás: Közvetlen API integráció teljesen megkerüli az SMTP-t

// WordPress kapcsolatfelvételi űrlap, amely a Kimenő mappába ment
await fetch('https://api.forwardemail.net/v1/messages', {
  method: 'POST',
  headers: {
    'Authorization': 'Basic ' + btoa('[email protected]:password'),
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    to: [{ address: '[email protected]' }],
    subject: 'Kapcsolatfelvételi űrlap: ' + formData.subject,
    text: formData.message,
    folder: 'Sent'
  })
});

2. Zapier alternatíva e-mail automatizáláshoz

Probléma: Zapier 10 e-mail/óra korlátja és IMAP észlelési hibák Megoldás: Korlátlan automatizálás teljes e-mail vezérléssel

// E-mailek automatikus rendezése feladó domain alapján
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áció

Probléma: Manuális kapcsolattartás e-mail és CRM rendszerek között Megoldás: Kétirányú szinkronizáció CardDAV kapcsolati API-val

// Új e-mail kapcsolatok szinkronizálása a CRM-be
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 rendelés feldolgozás

Probléma: Manuális rendelés e-mail feldolgozás e-kereskedelmi platformokon Megoldás: Automatizált rendeléskezelési folyamat

// Rendelés visszaigazoló e-mailek feldolgozása
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 jegy integráció

Probléma: E-mail szálak szétszórva helpdesk platformokon Megoldás: Teljes e-mail szál követés

// Támogatási jegy létrehozása e-mail szálból
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él kezelő rendszer

Probléma: Korlátozott hírlevél platform integrációk Megoldás: Teljes előfizetői életciklus kezelése

// Hírlevél feliratkozások automatikus kezelése
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: Bejövő levelek 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. Multi-Account Email Aggregation

Problem: Managing multiple email accounts across providers Solution: Unified inbox interface

// Aggregate emails from multiple accounts
const accounts = ['[email protected]', '[email protected]'];
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. Advanced Email Analytics Dashboard

Problem: No insights into email patterns with sophisticated filtering Solution: Custom email analytics using advanced search capabilities

// 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/[email protected]');
const urgentVipEmails = await fetch('/v1/[email protected]&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. Smart Email Archiving

Problem: Manual email organization Solution: Intelligent email categorization

// 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. Email-to-Calendar Integration

Problem: Manual calendar event creation from emails Solution: Automatic event extraction and creation

// 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ési és megfelelőségi követelmények
Megoldás: Automatikus biztonsági mentés metaadatok megőrzésével

// E-mailek biztonsági mentése teljes metaadatokkal
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: Tartalom beküldések kezelése e-mailen keresztül CMS platformok számára
Megoldás: E-mail mint tartalomkezelő rendszer

// Tartalom beküldések feldolgozása e-mailből
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 Sablonkezelés

Probléma: Inkonzisztens e-mail sablonok a csapatban
Megoldás: Központosított sablonrendszer API-val

// Sablonosított e-mailek küldése dinamikus tartalommal
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-mailen keresztül
Megoldás: Automatizált munkafolyamat-indítók

// Jóváhagyási e-mailek feldolgozása
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ági Megfigyelés

Probléma: Manuális biztonsági fenyegetés felismerés
Megoldás: Automatizált fenyegetés elemzés

// Gyanús e-mailek figyelése
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és Gyűjtés

Probléma: Manuális felmérés válaszok feldolgozása
Megoldás: Automatikus válaszgyűjtés

// Felmérés válaszok gyűjtése és feldolgozása
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ény Figyelés

Probléma: Nincs átláthatóság az e-mail kézbesítési teljesítmény terén
Megoldás: Valós idejű e-mail mutatók

// E-mail kézbesítési teljesítmény figyelése
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ú lead minősítés

Probléma: Manuális lead scoring e-mail interakciókból
Megoldás: Automatikus lead 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 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észletkezelés

Probléma: Manuális készletfrissítés beszállítói e-mailekből
Megoldás: Automatikus 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: Automatikus számla kinyerés és könyvelési rendszer szinkronizáció

// 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: Automatikus résztvevőkezelés és naptár integrá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: Bonyolult dokumentum jóváhagyási láncok e-mailen keresztül
Megoldás: Automatizált jóváhagyás követés és dokumentum verzió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 ügyfél visszajelzés gyűjtés és érzelem elemzés
Megoldás: Automatizált visszajelzés feldolgozás és érzelem kö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ölt kö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égelszámolás feldolgozás

Probléma: Manuális költségelszámolás benyújtás és jóváhagyás
Megoldás: Automatizált költség kinyerés é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é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ú beszállítókezelés

Probléma: Manuális beszállítói kommunikáció és szerződéskövetés
Megoldás: Automatizált beszállítói kapcsolatok kezelése

// 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: '[email protected]',
      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álaszadás
Megoldás: Automatizált közösségi média riasztások feldolgozása és válasz koordinációja

// 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: '[email protected]'
    });

    // 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: ['[email protected]']
      })
    });
  }
}

Első lépések

1. Hozd létre az átirányító e-mail fiókodat

Regisztrálj a forwardemail.net oldalon, és igazold a domainedet.

2. Generáld le az API hitelesítő adatokat

Az alias e-mail címed és jelszavad szolgálnak API hitelesítő adatként – további beállítás nem szükséges.

3. Tegye meg az első API hívását

# Listázza az üzeneteit
curl -u "[email protected]:password" \
  https://api.forwardemail.net/v1/messages

# Hozzon létre egy új kapcsolatot
curl -u "[email protected]:password" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"fullName":"John Doe","emails":[{"value":"[email protected]"}]}' \
  https://api.forwardemail.net/v1/contacts

4. Fedezze fel a dokumentációt

Látogasson el a forwardemail.net/en/email-api oldalra a teljes API dokumentációért interaktív példákkal.

Műszaki források

Készen áll arra, hogy forradalmasítsa az e-mail integrációját? Kezdje el építeni a Forward Email API-jával még ma, és tapasztalja meg az első teljes körű e-mail kezelő platformot, amelyet kifejezetten fejlesztőknek terveztek.

Forward Email: Az e-mail szolgáltatás, amely végre jól kezeli az API-kat.