Den Første Komplette Email API: Hvordan Forward Email Revolutionerede Email Administration

Complete email API with IMAP CardDAV CalDAV REST

TL;DR: Vi byggede verdens første komplette REST API til email-administration med avancerede søgemuligheder, som ingen anden tjeneste tilbyder. Mens Gmail, Outlook og Apple tvinger udviklere ind i IMAP-helvede eller rate-begrænsede API'er, leverer Forward Email lynhurtige CRUD-operationer for beskeder, mapper, kontakter og kalendere gennem en samlet REST-grænseflade med 15+ søgeparametre. Dette er den email API, udviklere har ventet på.

Problemet med Email API'er

Email API'er er grundlæggende ødelagte. Punktum.

Hver eneste større email-udbyder tvinger udviklere til et af to forfærdelige valg:

  1. IMAP Helvede: At kæmpe med en 30 år gammel protokol designet til desktop-klienter, ikke moderne applikationer
  2. Handicappede API'er: Rate-begrænsede, skrivebeskyttede, OAuth-komplekse API'er, der ikke kan håndtere dine faktiske email-data

Resultatet? Udviklere opgiver enten email-integration helt eller spilder uger på at bygge skrøbelige IMAP-wrapper, der konstant går i stykker.

Warning

Den beskidte hemmelighed: De fleste "email API'er" er bare sending API'er. Du kan ikke programmere til at organisere mapper, synkronisere kontakter eller administrere kalendere gennem en simpel REST-grænseflade. Indtil nu.

Hvad Udviklere Faktisk Siger

Frustrationen er reel og dokumenteret overalt:

"Jeg prøvede for nylig at integrere Gmail i min app, og jeg brugte alt for meget tid på det. Jeg besluttede, at det ikke er værd at støtte Gmail."

- Hacker News udvikler, 147 upvotes

"Er alle email API'er middelmådige? De virker begrænsede eller restriktive på en eller anden måde."

- Reddit r/SaaS diskussion

"Hvorfor skal email-udvikling være så træls?"

- Reddit r/webdev, 89 kommentarer om udvikler-smerte

"Hvad gør Gmail API mere effektiv end IMAP? En anden grund til, at Gmail API er meget mere effektiv, er fordi den kun behøver at downloade hver besked én gang. Med IMAP skal hver besked downloades og indekseres..."

- Stack Overflow spørgsmål med 47 upvotes

Beviserne er overalt:

  • WordPress SMTP problemer: 631 GitHub issues om email-leveringsfejl
  • Zapier begrænsninger: Community klager om 10 emails/time grænser og IMAP detektionsfejl
  • IMAP API projekter: Flere open-source projekter findes specifikt for at "konvertere IMAP til REST", fordi ingen udbyder tilbyder dette
  • Gmail API frustrationer: Stack Overflow har 4.847 spørgsmål tagget "gmail-api" med almindelige klager om rate limits og kompleksitet

Forward Emails Revolutionerende Løsning

Vi er den første email-service, der tilbyder komplette CRUD-operationer for alle email-data gennem en samlet REST API.

Dette er ikke bare endnu en sending API. Dette er komplet programmatisk kontrol over:

  • Beskeder: Opret, læs, opdater, slet, søg, flyt, marker
  • Mapper: Fuld IMAP mappeadministration via REST endpoints
  • Kontakter: CardDAV kontaktlagring og synkronisering
  • Kalendere: CalDAV kalenderbegivenheder og planlægning

Hvorfor Vi Byggede Dette

Problemet: Hver email-udbyder behandler email som en sort boks. Du kan sende emails, måske læse dem med kompleks OAuth, men du kan ikke virkelig administrere dine email-data programmatisk.

Vores Vision: Email skal være lige så let at integrere som enhver moderne API. Ingen IMAP-biblioteker. Ingen OAuth-kompleksitet. Ingen rate limit mareridt. Bare simple REST endpoints, der virker.

Resultatet: Den første email-service, hvor du kan bygge en komplet email-klient, CRM-integration eller automatiseringssystem ved kun at bruge HTTP-forespørgsler.

Simpel Autentifikation

Ingen OAuth-kompleksitet. Ingen app-specifikke adgangskoder. Bare dine alias-legitimationsoplysninger:

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

20 Endpoints der ændrer alt

Beskeder (5 endpoints)

  • GET /v1/messages - Liste beskeder med filtrering (?folder=, ?is_unread=, ?is_flagged=)
  • POST /v1/messages - Send nye beskeder direkte til mapper
  • GET /v1/messages/:id - Hent specifik besked med fuld metadata
  • PUT /v1/messages/:id - Opdater besked (flag, mappe, læst status)
  • DELETE /v1/messages/:id - Slet besked permanent

Mapper (5 endpoints)

  • GET /v1/folders - Liste alle mapper med abonnementsstatus
  • POST /v1/folders - Opret ny mappe med brugerdefinerede egenskaber
  • GET /v1/folders/:id - Hent mappens detaljer og beskedtællinger
  • PUT /v1/folders/:id - Opdater mappens egenskaber og abonnement
  • DELETE /v1/folders/:id - Slet mappe og håndter beskedflytning

Kontakter (5 endpoints)

  • GET /v1/contacts - Liste kontakter med søgning og paginering
  • POST /v1/contacts - Opret ny kontakt med fuld vCard support
  • GET /v1/contacts/:id - Hent kontakt med alle felter og metadata
  • PUT /v1/contacts/:id - Opdater kontaktinformation med ETag validering
  • DELETE /v1/contacts/:id - Slet kontakt med kaskadehåndtering

Kalendere (5 endpoints)

  • GET /v1/calendars - Liste kalenderbegivenheder med datofiltrering
  • POST /v1/calendars - Opret kalenderbegivenhed med deltagere og gentagelse
  • GET /v1/calendars/:id - Hent begivenhedsdetaljer med tidszonehåndtering
  • PUT /v1/calendars/:id - Opdater begivenhed med konfliktregistrering
  • DELETE /v1/calendars/:id - Slet begivenhed med deltagerunderretninger

Avanceret søgning: Ingen anden tjeneste kan måle sig

Forward Email er den eneste e-mail tjeneste, der tilbyder omfattende, programmatisk søgning på tværs af alle beskedfelter via en REST API.

Mens andre udbydere højst tilbyder grundlæggende filtrering, har vi bygget den mest avancerede e-mail søge-API nogensinde. Ingen Gmail API, Outlook API eller anden tjeneste kommer i nærheden af vores søgemuligheder.

Søge-API-landskabet er brudt

Gmail API søgebegrænsninger:

  • ✅ Grundlæggende q parameter kun
  • ❌ Ingen felt-specifik søgning
  • ❌ Ingen datointerval filtrering
  • ❌ Ingen størrelsesbaseret filtrering
  • ❌ Ingen vedhæftningsfiltrering
  • ❌ Begrænset til Gmail's søgesyntaks

Outlook API søgebegrænsninger:

  • ✅ Grundlæggende $search parameter
  • ❌ Ingen avanceret feltmålretning
  • ❌ Ingen komplekse forespørgselskombinationer
  • ❌ Aggressiv ratebegrænsning
  • ❌ Kompliceret OData syntaks krævet

Apple iCloud:

  • ❌ Ingen API overhovedet
  • ❌ Kun IMAP-søgning (hvis du kan få det til at virke)

ProtonMail & Tuta:

  • ❌ Ingen offentlige API'er
  • ❌ Ingen programmatisk søgemuligheder

Forward Emails revolutionerende søge-API

Vi tilbyder 15+ søgeparametre, som ingen anden tjeneste leverer:

Søgemulighed Forward Email Gmail API Outlook API Andre
Felt-specifik søgning ✅ Emne, indhold, fra, til, cc, headers ❌ ❌ ❌
Multi-felt generel søgning ✅ ?search= på tværs af alle felter ✅ Grundlæggende q= ✅ Grundlæggende $search= ❌
Datointerval filtrering ✅ ?since= & ?before= ❌ ❌ ❌
Størrelsesbaseret filtrering ✅ ?min_size= & ?max_size= ❌ ❌ ❌
Vedhæftningsfiltrering ✅ ?has_attachments=true/false ❌ ❌ ❌
Header-søgning ✅ ?headers=X-Priority ❌ ❌ ❌
Besked-ID søgning ✅ ?message_id=abc123 ❌ ❌ ❌
Kombinerede filtre ✅ Flere parametre med OG-logik ❌ ❌ ❌
Case-insensitiv ✅ Alle søgninger ✅ ✅ ❌
Paginering understøttet ✅ Fungerer med alle søgeparametre ✅ ✅ ❌

Real-World Search Examples

Find All Invoices from Last Quarter:

# 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

Search for Large Attachments from Specific Sender:

# 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

Complex Multi-Field Search:

# 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"

Performance Advantages

Forward Email Search Performance:

  • ⚡ Sub-100ms svartider for komplekse søgninger
  • 🔍 Regex-optimering med korrekt indeksering
  • 📊 Parallel forespørgselsudførelse for tælling og data
  • 💾 Effektiv hukommelsesbrug med slanke forespørgsler

Competitor Performance Issues:

  • 🐌 Gmail API: Ratebegrænset til 250 kvotaenheder per bruger per sekund
  • 🐌 Outlook API: Aggressiv throttling med komplekse backoff-krav
  • 🐌 Others: Ingen API'er til sammenligning

Search Features No One Else Has

# Find messages with specific headers
GET /v1/messages?headers=X-Priority:1
GET /v1/messages?headers=X-Spam-Score

2. Size-Based Intelligence

# 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. Attachment-Based Workflows

# 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. Combined Business Logic

# Find urgent flagged messages from VIPs with attachments
GET /v1/messages?is_flagged=true&from=ceo&has_attachments=true&subject=urgent

Why This Matters for Developers

Build Applications That Were Previously Impossible:

  1. Avanceret e-mailanalyse: Analyser e-mailmønstre efter størrelse, afsender, indhold
  2. Intelligent e-mailstyring: Auto-organiser baseret på komplekse kriterier
  3. Overholdelse og opdagelse: Find specifikke e-mails til juridiske krav
  4. Forretningsindsigt: Udtræk indsigt fra e-mailkommunikationsmønstre
  5. Automatiserede workflows: Udløs handlinger baseret på sofistikerede e-mailfiltre

The Technical Implementation

Our search API uses:

  • Regex optimization with proper indexing strategies
  • Parallel execution for performance
  • Input validation for security
  • Comprehensive error handling for reliability
// 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

Developer Advantage: With Forward Email's search API, you can build email applications that rival desktop clients in functionality while maintaining the simplicity of REST APIs.

Lynhurtig Ydeevne Arkitektur

Vores tekniske stack er bygget til hastighed og pålidelighed:

Ydeevne Benchmarks

Hvorfor vi er lynhurtige:

Komponent Teknologi Ydeevnefordel
Lagring NVMe SSD 10x hurtigere end traditionel SATA
Database SQLite + msgpackr Ingen netværksforsinkelse, optimeret serialisering
Hardware AMD Ryzen bare metal Ingen virtualiseringsomkostninger
Caching In-memory + persistent Responstider under millisekunder
Backups Cloudflare R2 krypteret Enterprise-niveau pålidelighed

Reelle Ydeevnetal:

  • API Responstid: < 50ms i gennemsnit
  • Beskedhentning: < 10ms for cachede beskeder
  • Mappeoperationer: < 5ms for metadataoperationer
  • Kontakt-synkronisering: 1000+ kontakter/sekund
  • Oppetid: 99,99% SLA med redundant infrastruktur

Privatliv-først Arkitektur

Zero-Knowledge Design: Kun du har adgang med din IMAP-adgangskode – vi kan ikke læse dine e-mails. Vores zero-knowledge arkitektur sikrer fuldstændigt privatliv samtidig med lynhurtig ydeevne.

Hvorfor vi er forskellige: Den komplette sammenligning

Store Udbyderbegrænsninger

Udbyder Kerneproblemer Specifikke Begrænsninger
Gmail API Read-only, Komplekst OAuth, Separate API'er • Kan ikke ændre eksisterende beskeder
• Labels ≠ mapper
• 1 milliard kvoteenheder/dag grænse
• Kræver separate API'er til kontakter/kalender
Outlook API Udfaset, Forvirrende, Enterprise-fokuseret • REST-endpoints udfaset marts 2024
• Flere forvirrende API'er (EWS, Graph, REST)
• Microsoft Graph kompleksitet
• Aggressiv throttling
Apple iCloud Ingen offentlig API • Ingen offentlig API overhovedet
• Kun IMAP med 1000 e-mails/dag grænse
• App-specifikke adgangskoder kræves
• 500 modtagere pr. besked grænse
ProtonMail Ingen API, Falske open-source påstande • Ingen offentlig API tilgængelig
• Bridge-software kræves for IMAP-adgang
• Påstår "open source" men serverkode er proprietær
• Begrænset til betalte planer
Tuta Ingen API, Vildledende gennemsigtighed • Ingen REST API til e-mailhåndtering
• Påstår "open source" men backend er lukket
• IMAP/SMTP understøttes ikke
• Proprietær kryptering forhindrer standardintegrationer
Zapier Email Alvorlige ratebegrænsninger • 10 e-mails pr. time grænse
• Ingen IMAP-mappeadgang
• Begrænsede parser-funktioner

Fordele ved Forward Email

Funktion Forward Email Konkurrence
Fuld CRUD ✅ Fuld oprettelse, læsning, opdatering, sletning for alle data ❌ Kun læseadgang eller begrænsede funktioner
Enheds-API ✅ Beskeder, mapper, kontakter, kalendere i én API ❌ Separate API'er eller manglende funktioner
Simpel Auth ✅ Grundlæggende autentificering med alias-legitimationsoplysninger ❌ Komplekst OAuth med flere scopes
Ingen Rate Limits ✅ Generøse grænser designet til rigtige applikationer ❌ Restriktive kvoter, der bryder arbejdsgange
Selv-hosting ✅ Fuld selv-hosting mulighed ❌ Kun leverandørlåsning
Privatliv ✅ Zero-knowledge, krypteret, privat ❌ Dataudvinding og privatlivsproblemer
Ydeevne ✅ Under 50 ms responstid, NVMe-lagring ❌ Netværksforsinkelse, throttling-forsinkelser

Problemet med Open-Source Transparens

ProtonMail og Tuta markedsfører sig som "open source" og "transparente," men dette er vildledende markedsføring, der bryder med moderne privatlivsprincipper.

Warning

Falske Transparenspåstande: Både ProtonMail og Tuta reklamerer fremtrædende med deres "open source"-kvalifikationer, mens deres mest kritiske server-side kode er proprietær og lukket.

ProtonMails bedrag:

  • Påstande: "Vi er open source" fremhævet i markedsføring
  • Virkelighed: Serverkode er fuldstændig proprietær – kun klientapps er open source
  • Konsekvens: Brugere kan ikke verificere server-side kryptering, datahåndtering eller privatlivspåstande
  • Brud på transparens: Ingen mulighed for at revidere de faktiske e-mail behandlings- og lagringssystemer

Tutas vildledende markedsføring:

  • Påstande: "Open source email" som et kerne-salgsargument
  • Virkelighed: Backend-infrastruktur er lukket kilde – kun frontend er tilgængelig
  • Konsekvens: Proprietær kryptering forhindrer standard e-mail protokoller (IMAP/SMTP)
  • Låsestrategi: Tilpasset kryptering tvinger leverandørafhængighed

Hvorfor dette er vigtigt for moderne privatliv:

I 2025 kræver ægte privatliv fuldstændig transparens. Når e-mail-udbydere påstår "open source" men skjuler deres serverkode:

  1. Uverificerbar kryptering: Du kan ikke revidere, hvordan dine data faktisk krypteres
  2. Skjulte datapraksisser: Server-side datahåndtering forbliver en sort boks
  3. Tillidsbaseret sikkerhed: Du må stole på deres påstande uden verifikation
  4. Leverandørlåsning: Proprietære systemer forhindrer dataportabilitet

Forward Emails ægte transparens:

  • ✅ Fuld open source – server- og klientkode
  • ✅ Selv-hosting tilgængeligt – kør din egen instans
  • ✅ Standardprotokoller – IMAP, SMTP, CardDAV, CalDAV kompatibilitet
  • ✅ Reviderbar sikkerhed – hver linje kode kan inspiceres
  • ✅ Ingen leverandørlåsning – dine data, din kontrol

Tip

Ægte open source betyder, at du kan verificere hver påstand. Med Forward Email kan du revidere vores kryptering, gennemgå vores datahåndtering og endda køre din egen instans. Det er ægte transparens.

30+ Eksempler på Integration i Den Virkelige Verden

1. Forbedring af WordPress Kontaktformular

Problem: WordPress SMTP-konfigurationsfejl (631 GitHub issues) Løsning: Direkte API-integration omgår SMTP fuldstændigt

// WordPress kontaktformular, der gemmer i Sendt-mappen
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: 'Kontaktformular: ' + formData.subject,
    text: formData.message,
    folder: 'Sent'
  })
});

2. Zapier-alternativ til e-mail-automatisering

Problem: Zapiers grænse på 10 e-mails/time og IMAP-detekteringsfejl Løsning: Ubegrænset automatisering med fuld e-mail-kontrol

// Auto-organiser e-mails efter afsenderdomæne
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-synkronisering

Problem: Manuel kontaktstyring mellem e-mail og CRM-systemer Løsning: To-vejs synkronisering med CardDAV kontakt-API

// Synkroniser nye e-mailkontakter til 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-handelsordrebehandling

Problem: Manuel ordre-e-mailbehandling for e-handelsplatforme Løsning: Automatiseret ordrebehandlingspipeline

// Behandl ordrebekræftelses-e-mails
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. Supportticket-integration

Problem: E-mailtråde spredt over helpdesk-platforme Løsning: Fuld sporbarhed af e-mailtråde

// Opret supportticket fra e-mailtråd
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. Nyhedsbrevsstyringssystem

Problem: Begrænsede integrationer til nyhedsbrevsplatforme Løsning: Fuld styring af abonnenters livscyklus

// Automatisk håndtering af nyhedsbrevsabonnementer
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-mailbaseret opgavestyring

Problem: Overvældet indbakke og opgavestyring Løsning: Konverter e-mails til handlingsorienterede opgaver

// 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. Email Backup og Overholdelse

Problem: Email retention og overholdelseskrav
Løsning: Automatisk backup med metadata-bevarelse

// 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. Email-baseret Indholdsstyring

Problem: Håndtering af indholdsforslag via email til CMS-platforme
Løsning: Email som indholdsstyringssystem

// 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. Email Skabelonstyring

Problem: Inkonsistente email-skabeloner på tværs af teamet
Løsning: Centraliseret skabelonsystem med API

// 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. Email-baseret Workflow Automation

Problem: Manuelle godkendelsesprocesser via email
Løsning: Automatiserede workflow-triggere

// 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. Email Sikkerhedsovervågning

Problem: Manuel sikkerhedstrussel-detektion
Løsning: Automatisk trusselanalyse

// 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. Email-baseret Undersøgelsesindsamling

Problem: Manuel behandling af undersøgelsessvar
Løsning: Automatisk svaraggregation

// 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. Email Performance Overvågning

Problem: Ingen indsigt i email leveringsperformance
Løsning: Real-time email-målinger

// 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. Email-baseret Lead Kvalificering

Problem: Manuel lead scoring fra email-interaktioner
Løsning: Automatiseret lead kvalificeringspipeline

// Score leads baseret på 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. Email-baseret Projektstyring

Problem: Projektopdateringer spredt over email-tråde
Løsning: Centraliseret projektkommunikationshub

// Udtræk projektopdateringer fra 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. Email-baseret Lagerstyring

Problem: Manuel lageropdatering fra leverandør-emails
Løsning: Automatiseret lagerstyring fra email-notifikationer

// Behandl lageropdateringer fra leverandør-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
  });

  // Flyt til behandlet mappe
  await fetch(`/v1/messages/${email.id}`, {
    method: 'PUT',
    body: JSON.stringify({ folder: 'Suppliers/Processed' })
  });
}

22. Email-baseret Fakturabehandling

Problem: Manuel fakturabehandling og regnskabsintegration
Løsning: Automatiseret fakturaundtrækning og synkronisering med regnskabssystem

// Udtræk fakturadata fra email-vedhæftninger
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
  });

  // Marker som behandlet
  await fetch(`/v1/messages/${email.id}`, {
    method: 'PUT',
    body: JSON.stringify({ flags: ['\\Seen', '\\Flagged'] })
  });
}

23. Email-baseret Eventregistrering

Problem: Manuel eventregistrering behandling fra email-svar
Løsning: Automatiseret deltagerstyring og kalenderintegration

// Behandl eventregistrerings-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);

  // Tilføj til deltagerliste
  await events.addAttendee({
    event: attendeeData.eventId,
    name: attendeeData.name,
    email: registration.from,
    dietary: attendeeData.dietaryRestrictions
  });

  // Opret kalenderbegivenhed for deltager
  await fetch('/v1/calendars', {
    method: 'POST',
    body: JSON.stringify({
      title: attendeeData.eventName,
      start: attendeeData.eventDate,
      attendees: [registration.from]
    })
  });
}

24. E-mail-baseret dokumentgodkendelsesworkflow

Problem: Komplekse dokumentgodkendelses kæder via e-mail
Løsning: Automatiseret godkendelsessporing og dokumentversionering

// 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-baseret kundefeedbackanalyse

Problem: Manuel kundefeedback indsamling og sentimentanalyse
Løsning: Automatiseret feedbackbehandling og sentimentsporing

// 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-baseret rekrutteringspipeline

Problem: Manuel rekruttering og kandidatsporing
Løsning: Automatiseret kandidatstyring og interviewplanlægning

// 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-baseret behandling af udgiftsrapporter

Problem: Manuel udgiftsrapport indsendelse og godkendelse
Løsning: Automatiseret udgiftsekstraktion og godkendelsesworkflow

// 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-baseret kvalitetskontrolrapportering

Problem: Manuel kvalitetssikring fejlsporing
Løsning: Automatiseret QA-fejlstyring og fejlsporing

// 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-baseret leverandørstyring

Problem: Manuel leverandørkommunikation og kontraktsporing
Løsning: Automatiseret leverandørforholdsstyring

// 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-baseret overvågning af sociale medier

Problem: Manuel overvågning af sociale medier og respons
Løsning: Automatiseret behandling af sociale mediealarmer og koordinering af svar

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

Kom godt i gang

1. Opret din videresendelses-e-mailkonto

Tilmeld dig på forwardemail.net og bekræft dit domæne.

2. Generer API-legitimationsoplysninger

Din alias-e-mail og adgangskode fungerer som API-legitimationsoplysninger – ingen yderligere opsætning kræves.

3. Foretag Dit Første API-kald

# List dine beskeder
curl -u "your-alias@domain.com:password" \
  https://api.forwardemail.net/v1/messages

# Opret en ny 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. Udforsk Dokumentationen

Besøg forwardemail.net/en/email-api for komplet API-dokumentation med interaktive eksempler.

Tekniske Ressourcer

Klar til at revolutionere din email-integration? Begynd at bygge med Forward Emails API i dag og oplev den første komplette email-administrationsplatform designet til udviklere.

Forward Email: Email-tjenesten der endelig forstår APIs.