První kompletní Email API: Jak Forward Email revolucionalizoval správu emailů

Complete email API with IMAP CardDAV CalDAV REST

TL;DR: Vytvořili jsme první kompletní REST API pro správu emailů na světě s pokročilými vyhledávacími schopnostmi, které žádná jiná služba nenabízí. Zatímco Gmail, Outlook a Apple nutí vývojáře do IMAP pekla nebo API s omezením rychlosti, Forward Email poskytuje bleskově rychlé CRUD operace pro zprávy, složky, kontakty a kalendáře prostřednictvím sjednoceného REST rozhraní s více než 15 vyhledávacími parametry. Toto je emailové API, na které vývojáři čekali.

Problém s Emailovým API

Emailová API jsou zásadně rozbitá. Tečka.

Každý hlavní poskytovatel emailu nutí vývojáře do jedné ze dvou hrozných voleb:

  1. IMAP peklo: Boj s 30 let starým protokolem navrženým pro desktopové klienty, ne pro moderní aplikace
  2. Omezená API: API s omezením rychlosti, pouze pro čtení, složitá OAuth API, která nedokážou spravovat vaše skutečná emailová data

Výsledek? Vývojáři buď úplně opustí integraci emailu, nebo ztrácejí týdny budováním křehkých IMAP wrapperů, které neustále padají.

Warning

Špinavé tajemství: Většina "emailových API" jsou jen API pro odesílání. Programově nemůžete organizovat složky, synchronizovat kontakty ani spravovat kalendáře přes jednoduché REST rozhraní. Až doposud.

Co Vývojáři Opravdu Říkají

Frustrace je skutečná a zdokumentovaná všude:

"Nedávno jsem se pokoušel integrovat Gmail do své aplikace a věnoval jsem tomu příliš mnoho času. Rozhodl jsem se, že nestojí za to Gmail podporovat."

- vývojář na Hacker News, 147 hlasů

"Jsou všechna emailová API průměrná? Zdají se být omezená nebo restriktivní nějakým způsobem."

- diskuze na Reddit r/SaaS

"Proč musí být vývoj emailu tak špatný?"

- Reddit r/webdev, 89 komentářů o bolesti vývojářů

"Co dělá Gmail API efektivnějším než IMAP? Dalším důvodem, proč je Gmail API mnohem efektivnější, je to, že každou zprávu musí stáhnout pouze jednou. U IMAP musí být každá zpráva stažena a indexována..."

- otázka na Stack Overflow s 47 hlasy

Důkazy jsou všude:

  • Problémy s WordPress SMTP: 631 GitHub issues týkajících se selhání doručení emailů
  • Omezení Zapieru: Stížnosti komunity na limity 10 emailů/hodinu a selhání detekce IMAP
  • Projekty IMAP API: Více open-source projektů existuje speciálně pro "převod IMAP na REST", protože žádný poskytovatel to nenabízí
  • Frustrace s Gmail API: Stack Overflow má 4 847 otázek označených "gmail-api" s běžnými stížnostmi na limity rychlosti a složitost

Revoluční Řešení Forward Email

Jsme první emailová služba, která nabízí kompletní CRUD operace pro všechna emailová data přes jednotné REST API.

Není to jen další API pro odesílání. Je to úplná programová kontrola nad:

  • Zprávami: Vytváření, čtení, aktualizace, mazání, vyhledávání, přesouvání, označování
  • Složkami: Plná správa IMAP složek přes REST endpointy
  • Kontakty: Ukládání a synchronizace kontaktů přes CardDAV
  • Kalendáři: Události a plánování kalendáře přes CalDAV

Proč jsme to vytvořili

Problém: Každý poskytovatel emailu považuje email za černou skříňku. Můžete posílat emaily, možná je číst přes složité OAuth, ale skutečně spravovat emailová data programově nemůžete.

Naše vize: Email by měl být stejně snadný na integraci jako jakékoliv moderní API. Žádné IMAP knihovny. Žádná složitost OAuth. Žádné noční můry s limity rychlosti. Jen jednoduché REST endpointy, které fungují.

Výsledek: První emailová služba, kde můžete postavit kompletní emailového klienta, CRM integraci nebo automatizační systém jen pomocí HTTP požadavků.

Jednoduchá autentizace

Žádná složitost OAuth. Žádná specifická hesla aplikací. Jen vaše aliasové přihlašovací údaje:

curl -u "alias@yourdomain.com:password" \
  https://api.forwardemail.net/v1/messages

20 Koncových bodů, které mění vše

Zprávy (5 koncových bodů)

  • GET /v1/messages - Výpis zpráv s filtrováním (?folder=, ?is_unread=, ?is_flagged=)
  • POST /v1/messages - Odeslat nové zprávy přímo do složek
  • GET /v1/messages/:id - Získat konkrétní zprávu s úplnými metadaty
  • PUT /v1/messages/:id - Aktualizovat zprávu (značky, složka, stav přečtení)
  • DELETE /v1/messages/:id - Trvale smazat zprávu

Složky (5 koncových bodů)

  • GET /v1/folders - Výpis všech složek s informací o odběru
  • POST /v1/folders - Vytvořit novou složku s vlastními vlastnostmi
  • GET /v1/folders/:id - Získat detaily složky a počty zpráv
  • PUT /v1/folders/:id - Aktualizovat vlastnosti složky a odběr
  • DELETE /v1/folders/:id - Smazat složku a zajistit přesun zpráv

Kontakty (5 koncových bodů)

  • GET /v1/contacts - Výpis kontaktů s vyhledáváním a stránkováním
  • POST /v1/contacts - Vytvořit nový kontakt s plnou podporou vCard
  • GET /v1/contacts/:id - Získat kontakt se všemi poli a metadaty
  • PUT /v1/contacts/:id - Aktualizovat informace o kontaktu s validací ETag
  • DELETE /v1/contacts/:id - Smazat kontakt s kaskádovým zpracováním

Kalendáře (5 koncových bodů)

  • GET /v1/calendars - Výpis událostí kalendáře s filtrováním podle data
  • POST /v1/calendars - Vytvořit událost kalendáře s účastníky a opakováním
  • GET /v1/calendars/:id - Získat detaily události s podporou časových pásem
  • PUT /v1/calendars/:id - Aktualizovat událost s detekcí konfliktů
  • DELETE /v1/calendars/:id - Smazat událost s notifikacemi účastníkům

Pokročilé vyhledávání: Žádná jiná služba se nevyrovná

Forward Email je jediná e-mailová služba, která nabízí komplexní, programové vyhledávání ve všech polích zpráv přes REST API.

Zatímco ostatní poskytovatelé nabízejí v lepším případě základní filtrování, my jsme vytvořili nejpokročilejší API pro vyhledávání e-mailů, jaké kdy bylo vytvořeno. Žádné Gmail API, Outlook API ani jiná služba se našim vyhledávacím schopnostem ani nepřibližuje.

Krajina API pro vyhledávání je rozbitá

Omezení vyhledávání v Gmail API:

  • ✅ Pouze základní parametr q
  • ❌ Žádné vyhledávání podle konkrétních polí
  • ❌ Žádné filtrování podle rozsahu dat
  • ❌ Žádné filtrování podle velikosti
  • ❌ Žádné filtrování příloh
  • ❌ Omezeno na syntaxi vyhledávání Gmailu

Omezení vyhledávání v Outlook API:

  • ✅ Základní parametr $search
  • ❌ Žádné pokročilé cílení na pole
  • ❌ Žádné složité kombinace dotazů
  • ❌ Přísné omezení počtu požadavků
  • ❌ Vyžaduje složitou syntaxi OData

Apple iCloud:

  • ❌ Žádné API vůbec
  • ❌ Pouze IMAP vyhledávání (pokud se vám podaří fungovat)

ProtonMail & Tuta:

  • ❌ Žádná veřejná API
  • ❌ Žádné programové vyhledávací schopnosti

Revoluční vyhledávací API Forward Email

Nabízíme více než 15 parametrů vyhledávání, které žádná jiná služba neposkytuje:

Možnost vyhledávání Forward Email Gmail API Outlook API Ostatní
Vyhledávání podle pole ✅ Předmět, tělo, od, komu, cc, hlavičky ❌ ❌ ❌
Vícepolní obecné vyhledávání ✅ ?search= napříč všemi poli ✅ Základní q= ✅ Základní $search= ❌
Filtrování podle rozsahu dat ✅ ?since= & ?before= ❌ ❌ ❌
Filtrování podle velikosti ✅ ?min_size= & ?max_size= ❌ ❌ ❌
Filtrování příloh ✅ ?has_attachments=true/false ❌ ❌ ❌
Vyhledávání v hlavičkách ✅ ?headers=X-Priority ❌ ❌ ❌
Vyhledávání podle ID zprávy ✅ ?message_id=abc123 ❌ ❌ ❌
Kombinované filtry ✅ Více parametrů s logikou AND ❌ ❌ ❌
Bez rozlišování velikosti písmen ✅ Všechny vyhledávání ✅ ✅ ❌
Podpora stránkování ✅ Funguje se všemi parametry vyhledávání ✅ ✅ ❌

Příklady vyhledávání v reálném světě

Najděte všechny faktury z minulého čtvrtletí:

# Forward Email - Jednoduché a výkonné
GET /v1/messages?subject=invoice&since=2024-01-01T00:00:00Z&before=2024-04-01T00:00:00Z

# Gmail API - Nemožné s jejich omezeným vyhledáváním
# Není k dispozici filtrování podle rozsahu dat

# Outlook API - Složitá syntaxe OData, omezená funkčnost
GET /me/messages?$search="invoice"&$filter=receivedDateTime ge 2024-01-01T00:00:00Z

Vyhledávání velkých příloh od konkrétního odesílatele:

# Forward Email - Komplexní filtrování
GET /v1/messages?from=finance@company.com&has_attachments=true&min_size=1000000

# Gmail API - Nelze programově filtrovat podle velikosti nebo příloh
# Outlook API - Není k dispozici filtrování podle velikosti
# Ostatní - Žádné dostupné API

Složitý vícepoložkový dotaz:

# Forward Email - Pokročilé možnosti dotazování
GET /v1/messages?body=quarterly&from=manager&is_flagged=true&folder=Reports

# Gmail API - Omezeno pouze na základní textové vyhledávání
GET /gmail/v1/users/me/messages?q=quarterly

# Outlook API - Základní vyhledávání bez cílení na pole
GET /me/messages?$search="quarterly"

Výhody výkonu

Výkon vyhledávání Forward Email:

  • ⚡ Odezva pod 100 ms u složitých vyhledávání
  • 🔍 Optimalizace pomocí regexu s řádným indexováním
  • 📊 Paralelní vykonávání dotazů pro počet i data
  • 💾 Efektivní využití paměti s úspornými dotazy

Problémy s výkonem konkurence:

  • 🐌 Gmail API: Limit na 250 kvótových jednotek na uživatele za sekundu
  • 🐌 Outlook API: Agresivní omezování s komplikovanými pravidly zpětného odkladu
  • 🐌 Ostatní: Žádná API k porovnání

Funkce vyhledávání, které nikdo jiný nemá

# Najděte zprávy s konkrétními hlavičkami
GET /v1/messages?headers=X-Priority:1
GET /v1/messages?headers=X-Spam-Score

2. Inteligence založená na velikosti

# Najděte newslettery (obvykle velké)
GET /v1/messages?min_size=50000&from=newsletter

# Najděte rychlé odpovědi (obvykle malé)
GET /v1/messages?max_size=1000&to=support

3. Pracovní postupy založené na přílohách

# Najděte všechny dokumenty zaslané právnímu týmu
GET /v1/messages?to=legal&has_attachments=true&body=contract

# Najděte e-maily bez příloh pro úklid
GET /v1/messages?has_attachments=false&before=2023-01-01T00:00:00Z

4. Kombinovaná obchodní logika

# Najděte urgentní označené zprávy od VIP s přílohami
GET /v1/messages?is_flagged=true&from=ceo&has_attachments=true&subject=urgent

Proč je to důležité pro vývojáře

Vytvářejte aplikace, které byly dříve nemožné:

  1. Pokročilá analýza e-mailů: Analyzujte vzory e-mailů podle velikosti, odesílatele, obsahu
  2. Inteligentní správa e-mailů: Automatická organizace na základě složitých kritérií
  3. Soulad a vyhledávání: Najděte konkrétní e-maily pro právní požadavky
  4. Business Intelligence: Získejte poznatky z komunikačních vzorců e-mailů
  5. Automatizované pracovní postupy: Spouštějte akce na základě sofistikovaných filtrů e-mailů

Technická implementace

Naše vyhledávací API používá:

  • Optimalizaci regexu s řádnými indexačními strategiemi
  • Paralelní vykonávání pro výkon
  • Validaci vstupů pro bezpečnost
  • Komplexní zpracování chyb pro spolehlivost
// Příklad: Implementace složitého vyhledávání
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' } }
    ]
  });
}

// Kombinace pomocí logiky AND
if (searchConditions.length > 0) {
  query.$and = searchConditions;
}

Tip

Výhoda pro vývojáře: S vyhledávacím API Forward Email můžete vytvářet e-mailové aplikace, které se funkčností vyrovnají desktopovým klientům a přitom si zachovávají jednoduchost REST API.

Architektura bleskově rychlého výkonu

Náš technický stack je postaven pro rychlost a spolehlivost:

Výkonnostní benchmarky

Proč jsme bleskově rychlí:

Komponenta Technologie Výhoda výkonu
Úložiště NVMe SSD 10x rychlejší než tradiční SATA
Databáze SQLite + msgpackr Žádná síťová latence, optimalizovaná serializace
Hardware AMD Ryzen bez virtualizace Žádné režijní náklady virtualizace
Cache V paměti + perzistentní Odezva v řádu pod milisekundy
Zálohy Cloudflare R2 šifrované Podniková úroveň spolehlivosti

Skutečná čísla výkonu:

  • Doba odezvy API: průměrně < 50 ms
  • Načítání zpráv: < 10 ms pro cachované zprávy
  • Operace se složkami: < 5 ms pro operace s metadaty
  • Synchronizace kontaktů: 1000+ kontaktů za sekundu
  • Dostupnost: 99,99 % SLA s redundantní infrastrukturou

Architektura zaměřená na soukromí

Zero-Knowledge design: Přístup máte pouze vy pomocí svého IMAP hesla – nemůžeme číst vaše e-maily. Naše zero-knowledge architektura zajišťuje úplné soukromí při zachování bleskového výkonu.

Proč jsme jiní: Kompletní srovnání

Hlavní omezení poskytovatelů

Poskytovatel Hlavní problémy Specifická omezení
Gmail API Pouze pro čtení, složitý OAuth, oddělená API • Nelze upravovat existující zprávy
• Štítky ≠ složky
• Limit 1 miliarda kvótových jednotek/den
• Vyžaduje oddělená API pro kontakty/kalendář
Outlook API Zastaralé, matoucí, zaměřené na podniky • REST endpointy zastaveny březen 2024
• Více matoucích API (EWS, Graph, REST)
• Složitost Microsoft Graph
• Agresivní omezování
Apple iCloud Žádné veřejné API • Žádné veřejné API vůbec
• Pouze IMAP s limitem 1000 e-mailů/den
• Vyžaduje hesla specifická pro aplikace
• Limit 500 příjemců na zprávu
ProtonMail Žádné API, falešné tvrzení o open-source • Žádné veřejné API dostupné
• Pro přístup přes IMAP je potřeba Bridge software
• Tvrdí, že je "open source", ale serverový kód je proprietární
• Omezeno pouze na placené plány
Tuta Žádné API, zavádějící transparentnost • Žádné REST API pro správu e-mailů
• Tvrdí, že je "open source", ale backend je uzavřený
• Nepodporuje IMAP/SMTP
• Proprietární šifrování znemožňuje standardní integrace
Zapier Email Přísná omezení rychlosti • Limit 10 e-mailů za hodinu
• Žádný přístup ke složkám IMAP
• Omezené možnosti parsování

Výhody přeposílání e-mailů

Funkce Přeposílání e-mailů Konkurence
Kompletní CRUD ✅ Plné vytváření, čtení, aktualizace, mazání všech dat ❌ Pouze čtení nebo omezené operace
Jednotné API ✅ Zprávy, složky, kontakty, kalendáře v jednom API ❌ Oddělená API nebo chybějící funkce
Jednoduchá autentizace ✅ Základní ověřování pomocí aliasových přihlašovacích údajů ❌ Komplexní OAuth s více oprávněními
Bez limitů rychlosti ✅ Štědré limity navržené pro reálné aplikace ❌ Restriktivní kvóty, které narušují pracovní postupy
Vlastní hosting ✅ Kompletní možnost vlastního hostingu ❌ Pouze závislost na dodavateli
Soukromí ✅ Zero-knowledge, šifrované, soukromé ❌ Těžba dat a obavy o soukromí
Výkon ✅ Odezvy pod 50 ms, NVMe úložiště ❌ Síťová latence, zpoždění kvůli omezení

Problém transparentnosti open-source

ProtonMail a Tuta se prezentují jako „open source“ a „transparentní“, ale jedná se o zavádějící marketing, který porušuje moderní zásady ochrany soukromí.

Warning

Falešná tvrzení o transparentnosti: ProtonMail i Tuta výrazně propagují své „open source“ kredity, přičemž jejich nejdůležitější serverový kód zůstává proprietární a uzavřený.

Dezinformace ProtonMailu:

  • Tvrzení: "Jsme open source" výrazně propagováno v marketingu
  • Realita: Serverový kód je zcela proprietární – pouze klientské aplikace jsou open source
  • Dopad: Uživatelé nemohou ověřit serverové šifrování, zpracování dat ani tvrzení o soukromí
  • Porušení transparentnosti: Není možné auditovat skutečné systémy zpracování a ukládání e-mailů

Zavádějící marketing Tuty:

  • Tvrzení: "Open source e-mail" jako hlavní prodejní bod
  • Realita: Backendová infrastruktura je uzavřená – dostupný je pouze frontend
  • Dopad: Proprietární šifrování znemožňuje standardní e-mailové protokoly (IMAP/SMTP)
  • Strategie uzamčení: Vlastní šifrování nutí závislost na dodavateli

Proč je to důležité pro moderní soukromí:

V roce 2025 vyžaduje skutečné soukromí úplnou transparentnost. Když poskytovatelé e-mailů tvrdí „open source“, ale skrývají svůj serverový kód:

  1. Neověřitelné šifrování: Nemůžete auditovat, jak jsou vaše data skutečně šifrována
  2. Skryté praktiky s daty: Zpracování dat na serveru zůstává černou skříňkou
  3. Bezpečnost založená na důvěře: Musíte věřit jejich tvrzením bez možnosti ověření
  4. Závislost na dodavateli: Proprietární systémy znemožňují přenositelnost dat

Skutečná transparentnost Forward Email:

  • ✅ Kompletní open source – serverový i klientský kód
  • ✅ Možnost vlastního hostingu – provozujte vlastní instanci
  • ✅ Standardní protokoly – kompatibilita s IMAP, SMTP, CardDAV, CalDAV
  • ✅ Auditovatelná bezpečnost – každý řádek kódu lze zkontrolovat
  • ✅ Bez závislosti na dodavateli – vaše data, vaše kontrola

Tip

Skutečný open source znamená, že můžete ověřit každé tvrzení. S Forward Email můžete auditovat naše šifrování, zkontrolovat zpracování dat a dokonce provozovat vlastní instanci. To je pravá transparentnost.

30+ příkladů reálných integrací

1. Vylepšení kontaktního formuláře WordPress

Problém: Selhání konfigurace SMTP ve WordPressu (631 GitHub issues)
Řešení: Přímá integrace API obchází SMTP úplně

// Kontaktní formulář WordPress, který ukládá do složky Odeslané
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: 'Kontaktní formulář: ' + formData.subject,
    text: formData.message,
    folder: 'Sent'
  })
});

2. Alternativa Zapier pro automatizaci e-mailů

Problém: Limit 10 e-mailů za hodinu u Zapieru a selhání detekce IMAP
Řešení: Neomezená automatizace s plnou kontrolou e-mailů

// Automatické třídění e-mailů podle domény odesílatele
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. Synchronizace e-mailů s CRM

Problém: Ruční správa kontaktů mezi e-mailem a CRM systémy
Řešení: Obousměrná synchronizace s CardDAV kontaktním API

// Synchronizace nových e-mailových kontaktů do 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. Zpracování objednávek v e-commerce

Problém: Ruční zpracování objednávek z e-mailů pro e-commerce platformy
Řešení: Automatizovaný proces správy objednávek

// Zpracování potvrzovacích e-mailů objednávek
const orders = await fetch('/v1/messages?folder=Orders');
const orderEmails = orders.filter(msg =>
  msg.subject.includes('Potvrzení objednávky')
);

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. Integrace podpory ticketů

Problém: E-mailové konverzace rozptýlené napříč helpdesk platformami
Řešení: Kompletní sledování e-mailových vláken

// Vytvoření ticketu podpory z e-mailového vlákna
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. Systém správy newsletterů

Problém: Omezené integrace newsletterových platforem
Řešení: Kompletní správa životního cyklu odběratelů

// Automatická správa odběrů newsletteru
const messages = await fetch('/v1/messages?folder=Newsletter');
const unsubscribes = messages.filter(msg =>
  msg.subject.toLowerCase().includes('odhlásit')
);

for (const msg of unsubscribes) {
  await removeSubscriber(msg.from);
  await fetch(`/v1/messages/${msg.id}`, {
    method: 'PUT',
    body: JSON.stringify({ folder: 'Newsletter/Unsubscribed' })
  });
}

7. Správa úkolů založená na e-mailech

Problém: Přetížení inboxu a sledování úkolů
Řešení: Převod e-mailů na proveditelné úkoly

// 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 = ['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. 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/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. 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. Zálohování e-mailů a dodržování předpisů

Problém: Uchovávání e-mailů a požadavky na dodržování předpisů
Řešení: Automatizované zálohování s uchováním metadat

// Zálohování e-mailů s kompletními metadaty
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. Správa obsahu založená na e-mailech

Problém: Správa odeslaného obsahu přes e-mail pro CMS platformy
Řešení: E-mail jako systém pro správu obsahu

// Zpracování odeslaného obsahu z e-mailu
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. Správa e-mailových šablon

Problém: Nekonzistentní e-mailové šablony v týmu
Řešení: Centralizovaný systém šablon s API

// Odesílání e-mailů se šablonou a dynamickým obsahem
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. Automatizace pracovních postupů založená na e-mailech

Problém: Ruční schvalovací procesy přes e-mail
Řešení: Automatizované spouštěče pracovních postupů

// Zpracování schvalovacích e-mailů
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. Monitorování bezpečnosti e-mailů

Problém: Ruční detekce bezpečnostních hrozeb
Řešení: Automatizovaná analýza hrozeb

// Monitorování podezřelých e-mailů
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. Sběr průzkumů založený na e-mailech

Problém: Ruční zpracování odpovědí na průzkumy
Řešení: Automatizovaná agregace odpovědí

// Sběr a zpracování odpovědí na průzkumy
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. Monitorování výkonu e-mailů

Problém: Žádný přehled o výkonu doručování e-mailů
Řešení: Metriky e-mailů v reálném čase

// Monitorování výkonu doručování e-mailů
const sentEmails = await fetch('/v1/messages?folder=Sent');
const deliveryStats = {
  sent: sentEmails.length,
  bounces: await countBounces(),
  deliveryRate: calculateDeliveryRate()
};
await updateDashboard(deliveryStats);

19. Kvalifikace leadů na základě e-mailu

Problém: Ruční lead scoring z e-mailových interakcí
Řešení: Automatizovaný pipeline pro kvalifikaci leadů

// 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. Projektové řízení na základě e-mailu

Problém: Aktualizace projektů rozptýlené v e-mailových vláknech
Řešení: Centralizované komunikační centrum pro projekty

// 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. Správa zásob na základě e-mailu

Problém: Ruční aktualizace zásob z e-mailů od dodavatelů
Řešení: Automatizované sledování zásob z e-mailových oznámení

// 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. Zpracování faktur na základě e-mailu

Problém: Ruční zpracování faktur a integrace s účetnictvím
Řešení: Automatizované extrahování faktur a synchronizace s účetním systémem

// 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. Registrace na akce na základě e-mailu

Problém: Ruční zpracování registrací na akce z e-mailových odpovědí
Řešení: Automatizovaná správa účastníků a integrace s kalendářem

// 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. Workflow schvalování dokumentů založený na e-mailech

Problém: Komplexní schvalovací řetězce dokumentů přes e-mail
Řešení: Automatizované sledování schvalování a verzování dokumentů

// 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. Analýza zpětné vazby zákazníků založená na e-mailech

Problém: Ruční sběr a analýza sentimentu zpětné vazby zákazníků
Řešení: Automatizované zpracování zpětné vazby a sledování sentimentu

// 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. Náborový proces založený na e-mailech

Problém: Ruční nábor a sledování kandidátů
Řešení: Automatizovaná správa kandidátů a plánování pohovorů

// 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. Zpracování výkazů výdajů založené na e-mailech

Problém: Ruční podávání a schvalování výkazů výdajů
Řešení: Automatizované extrahování výdajů a workflow schvalování

// 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. Email-Based Quality Assurance Reporting

Problém: Ruční sledování problémů zajištění kvality
Řešení: Automatizované řízení problémů QA a sledování chyb

// 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. Email-Based Vendor Management

Problém: Ruční komunikace s dodavateli a sledování smluv
Řešení: Automatizované řízení vztahů s dodavateli

// 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. Email-Based Social Media Monitoring

Problém: Ruční sledování zmínek na sociálních médiích a reakce
Řešení: Automatizované zpracování upozornění ze sociálních médií a koordinace odpovědí

// 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']
      })
    });
  }
}

Začínáme

1. Vytvořte si účet pro přeposílání e-mailů

Zaregistrujte se na forwardemail.net a ověřte svou doménu.

2. Vygenerujte API přihlašovací údaje

Váš alias e-mail a heslo slouží jako API přihlašovací údaje – není potřeba žádné další nastavení.

3. Proveďte svůj první API požadavek

# Vypsat své zprávy
curl -u "your-alias@domain.com:password" \
  https://api.forwardemail.net/v1/messages

# Vytvořit nový kontakt
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. Prozkoumejte dokumentaci

Navštivte forwardemail.net/en/email-api pro kompletní dokumentaci API s interaktivními příklady.

Technické zdroje

Připraveni revolucionalizovat svou emailovou integraci? Začněte dnes stavět s API Forward Email a zažijte první kompletní platformu pro správu emailů navrženou pro vývojáře.

Forward Email: Emailová služba, která konečně rozumí API správně.