Innholdsfortegnelse

Den første komplette e-post-API-en: Hvordan Forward Email revolusjonerte e-posthåndtering

Complete email API with IMAP CardDAV CalDAV REST

TL;DR: Vi bygde verdens første komplette REST API for e-posthåndtering med avanserte søkemuligheter som ingen annen tjeneste tilbyr. Mens Gmail, Outlook og Apple tvinger utviklere inn i IMAP-helvete eller rate-begrensede API-er, leverer Forward Email lynraske CRUD-operasjoner for meldinger, mapper, kontakter og kalendere gjennom et samlet REST-grensesnitt med 15+ søkeparametere. Dette er e-post-API-en utviklere har ventet på.

Problemet med e-post-APIer

E-post-APIer er fundamentalt ødelagte. Punktum.

Hver eneste stor e-postleverandør tvinger utviklere til ett av to forferdelige valg:

IMAP-helvete: Å slite med en 30 år gammel protokoll designet for skrivebordsprogrammer, ikke moderne applikasjoner
Handikappede APIer: Rate-begrensede, skrivebeskyttede, OAuth-komplekse APIer som ikke kan håndtere dine faktiske e-postdata

Resultatet? Utviklere gir enten opp e-postintegrasjon helt eller kaster bort uker på å bygge skjøre IMAP-innpakninger som stadig bryter sammen.

Warning

Den skitne hemmeligheten: De fleste "e-post-APIer" er bare sending-APIer. Du kan ikke programmere organisering av mapper, synkronisere kontakter eller administrere kalendere gjennom et enkelt REST-grensesnitt. Inntil nå.

Hva utviklere faktisk sier

Frustrasjonen er ekte og dokumentert overalt:

"Jeg prøvde nylig å integrere Gmail i appen min, og jeg brukte altfor mye tid på det. Jeg bestemte meg for at det ikke er verdt å støtte Gmail."

- Hacker News-utvikler, 147 oppstemmer

"Er alle e-post-APIer middelmådige? De virker begrensede eller restriktive på en eller annen måte."

- Reddit r/SaaS diskusjon

"Hvorfor må e-postutvikling være så vanskelig?"

- Reddit r/webdev, 89 kommentarer om utvikleres frustrasjon

"Hva gjør Gmail API mer effektivt enn IMAP? En annen grunn til at Gmail API er mye mer effektivt er fordi det bare trenger å laste ned hver melding én gang. Med IMAP må hver melding lastes ned og indekseres..."

- Stack Overflow spørsmål med 47 oppstemmer

Bevisene finnes overalt:

WordPress SMTP-problemer: 631 GitHub issues om feil ved e-postlevering
Zapier-begrensninger: Fellesskapsklager om 10 e-poster/time-grense og IMAP-deteksjonsfeil
IMAP API-prosjekter: Flere open-source prosjekter finnes spesielt for å "konvertere IMAP til REST" fordi ingen leverandør tilbyr dette
Gmail API-frustrasjoner: Stack Overflow har 4 847 spørsmål merket "gmail-api" med vanlige klager om ratebegrensninger og kompleksitet

Forward Emails revolusjonerende løsning

Vi er den første e-posttjenesten som tilbyr fullstendige CRUD-operasjoner for alle e-postdata gjennom et samlet REST API.

Dette er ikke bare et annet sending-API. Dette er full programmatisk kontroll over:

Meldinger: Opprett, les, oppdater, slett, søk, flytt, merk
Mapper: Full IMAP-mappehåndtering via REST-endepunkter
Kontakter: CardDAV kontaktlagring og synkronisering
Kalendere: CalDAV kalenderhendelser og planlegging

Hvorfor vi bygde dette

Problemet: Hver e-postleverandør behandler e-post som en svart boks. Du kan sende e-poster, kanskje lese dem med kompleks OAuth, men du kan ikke virkelig administrere e-postdataene dine programmert.

Vår visjon: E-post skal være like enkelt å integrere som hvilken som helst moderne API. Ingen IMAP-biblioteker. Ingen OAuth-kompleksitet. Ingen mareritt med ratebegrensninger. Bare enkle REST-endepunkter som fungerer.

Resultatet: Den første e-posttjenesten hvor du kan bygge en komplett e-postklient, CRM-integrasjon eller automatiseringssystem ved kun å bruke HTTP-forespørsler.

Enkel autentisering

Ingen OAuth-kompleksitet. Ingen app-spesifikke passord. Bare dine alias-legitimasjoner:

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

20 Endepunkter som Endrer Alt

Meldinger (5 endepunkter)

GET /v1/messages - List meldinger med filtrering (?folder=, ?is_unread=, ?is_flagged=)
POST /v1/messages - Send nye meldinger direkte til mapper
GET /v1/messages/:id - Hent spesifikk melding med full metadata
PUT /v1/messages/:id - Oppdater melding (flagg, mappe, lest status)
DELETE /v1/messages/:id - Slett melding permanent

Mapper (5 endepunkter)

GET /v1/folders - List alle mapper med abonnementsstatus
POST /v1/folders - Opprett ny mappe med egendefinerte egenskaper
GET /v1/folders/:id - Hent mappedetaljer og meldingsantall
PUT /v1/folders/:id - Oppdater mappeegenskaper og abonnement
DELETE /v1/folders/:id - Slett mappe og håndter meldingsoverføring

Kontakter (5 endepunkter)

GET /v1/contacts - List kontakter med søk og paginering
POST /v1/contacts - Opprett ny kontakt med full vCard-støtte
GET /v1/contacts/:id - Hent kontakt med alle felt og metadata
PUT /v1/contacts/:id - Oppdater kontaktinformasjon med ETag-validering
DELETE /v1/contacts/:id - Slett kontakt med kaskadehåndtering

Kalendere (5 endepunkter)

GET /v1/calendars - List kalenderhendelser med datofiltrering
POST /v1/calendars - Opprett kalenderhendelse med deltakere og gjentakelse
GET /v1/calendars/:id - Hent hendelsesdetaljer med tidssonehåndtering
PUT /v1/calendars/:id - Oppdater hendelse med konfliktoppdagelse
DELETE /v1/calendars/:id - Slett hendelse med deltakervarsler

Avansert Søk: Ingen Andre Tjenester Kan Måle Seg

Forward Email er den eneste e-posttjenesten som tilbyr omfattende, programmatisk søk på tvers av alle meldingsfelt gjennom en REST API.

Mens andre leverandører tilbyr grunnleggende filtrering på det beste, har vi bygget den mest avanserte e-postsøke-APIen som noensinne er laget. Ingen Gmail API, Outlook API eller noen annen tjeneste kommer i nærheten av våre søkemuligheter.

Søke-API-landskapet er Ødelagt

Begrensninger i Gmail API-søk:

✅ Grunnleggende q-parameter kun
❌ Ingen feltsøk
❌ Ingen datointervallfiltrering
❌ Ingen størrelsesbasert filtrering
❌ Ingen vedleggsfiltrering
❌ Begrenset til Gmails søkesyntaks

Begrensninger i Outlook API-søk:

✅ Grunnleggende $search-parameter
❌ Ingen avansert feltmålretting
❌ Ingen komplekse spørringskombinasjoner
❌ Aggressiv ratebegrensning
❌ Krever kompleks OData-syntaks

Apple iCloud:

❌ Ingen API i det hele tatt
❌ Kun IMAP-søk (hvis du får det til å fungere)

ProtonMail & Tuta:

❌ Ingen offentlige APIer
❌ Ingen programmatisk søkefunksjonalitet

Forward Emails Revolusjonerende Søke-API

Vi tilbyr 15+ søkeparametere som ingen andre tjenester tilbyr:

Søkemulighet	Forward Email	Gmail API	Outlook API	Andre
Feltsøk	✅ Emne, innhold, fra, til, kopi, headere	❌	❌	❌
Generelt søk på flere felt	✅ `?search=` på tvers av alle felt	✅ Grunnleggende `q=`	✅ Grunnleggende `$search=`	❌
Datointervallfiltrering	✅ `?since=` & `?before=`	❌	❌	❌
Størrelsesbasert filtrering	✅ `?min_size=` & `?max_size=`	❌	❌	❌
Vedleggsfiltrering	✅ `?has_attachments=true/false`	❌	❌	❌
Header-søk	✅ `?headers=X-Priority`	❌	❌	❌
Meldings-ID-søk	✅ `?message_id=abc123`	❌	❌	❌
Kombinerte filtre	✅ Flere parametere med OG-logikk	❌	❌	❌
Søk uten hensyn til store/små bokstaver	✅ Alle søk	✅	✅	❌
Støtte for paginering	✅ Fungerer med alle søkeparametere	✅	✅	❌

Eksempler på søk i virkeligheten

Finn alle fakturaer fra forrige kvartal:

# Forward Email - Enkelt og kraftig
GET /v1/messages?subject=invoice&since=2024-01-01T00:00:00Z&before=2024-04-01T00:00:00Z

# Gmail API - Umulig med deres begrensede søk
# Ingen mulighet for datointervallfiltrering

# Outlook API - Kompleks OData-syntaks, begrenset funksjonalitet
GET /me/messages?$search="invoice"&$filter=receivedDateTime ge 2024-01-01T00:00:00Z

Søk etter store vedlegg fra spesifikk avsender:

# Forward Email - Omfattende filtrering
GET /v1/messages?from=finance@company.com&has_attachments=true&min_size=1000000

# Gmail API - Kan ikke filtrere på størrelse eller vedlegg programmert
# Outlook API - Ingen mulighet for størrelsesfiltrering
# Andre - Ingen tilgjengelige API-er

Komplekst søk med flere felt:

# Forward Email - Avanserte spørringsmuligheter
GET /v1/messages?body=quarterly&from=manager&is_flagged=true&folder=Reports

# Gmail API - Begrenset til grunnleggende tekstsøk
GET /gmail/v1/users/me/messages?q=quarterly

# Outlook API - Grunnleggende søk uten feltspesifisering
GET /me/messages?$search="quarterly"

Ytelsesfordeler

Forward Email søkeytelse:

⚡ Svar på under 100 ms for komplekse søk
🔍 Regex-optimalisering med riktig indeksering
📊 Parallell spørringsutførelse for telling og data
💾 Effektiv minnebruk med slanke spørringer

Konkurrentenes ytelsesproblemer:

🐌 Gmail API: Begrenset til 250 kvoteenheter per bruker per sekund
🐌 Outlook API: Aggressiv throttling med komplekse backoff-krav
🐌 Andre: Ingen API-er å sammenligne med

Søkeegenskaper ingen andre har

1. Header-spesifikt søk

# Finn meldinger med spesifikke headere
GET /v1/messages?headers=X-Priority:1
GET /v1/messages?headers=X-Spam-Score

2. Størrelsesbasert intelligens

# Finn nyhetsbrev (typisk store)
GET /v1/messages?min_size=50000&from=newsletter

# Finn raske svar (typisk små)
GET /v1/messages?max_size=1000&to=support

3. Vedleggsbaserte arbeidsflyter

# Finn alle dokumenter sendt til juridisk avdeling
GET /v1/messages?to=legal&has_attachments=true&body=contract

# Finn e-poster uten vedlegg for opprydding
GET /v1/messages?has_attachments=false&before=2023-01-01T00:00:00Z

4. Kombinert forretningslogikk

# Finn viktige flaggede meldinger fra VIP-er med vedlegg
GET /v1/messages?is_flagged=true&from=ceo&has_attachments=true&subject=urgent

Hvorfor dette er viktig for utviklere

Bygg applikasjoner som tidligere var umulige:

Avansert e-postanalyse: Analyser e-postmønstre etter størrelse, avsender, innhold
Intelligent e-posthåndtering: Auto-organiser basert på komplekse kriterier
Samsvar og oppdagelse: Finn spesifikke e-poster for juridiske krav
Forretningsinnsikt: Hent ut innsikt fra e-postkommunikasjonsmønstre
Automatiserte arbeidsflyter: Utløse handlinger basert på sofistikerte e-postfiltre

Den tekniske implementasjonen

Vår søke-API bruker:

Regex-optimalisering med riktige indekseringsstrategier
Parallell utførelse for ytelse
Inputvalidering for sikkerhet
Omfattende feilhåndtering for pålitelighet

// Eksempel: Kompleks søkeimplementasjon
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' } }
    ]
  });
}

// Kombiner med OG-logikk
if (searchConditions.length > 0) {
  query.$and = searchConditions;
}

Tip

Utviklerfordel: Med Forward Emails søke-API kan du bygge e-postapplikasjoner som kan måle seg med desktop-klienter i funksjonalitet, samtidig som du beholder enkelheten til REST API-er.

Lynrask ytelsesarkitektur

Vår tekniske stack er bygget for hastighet og pålitelighet:

Ytelsesmålinger

Hvorfor vi er lynraske:

Komponent	Teknologi	Ytelsesfordel
Lagring	NVMe SSD	10x raskere enn tradisjonell SATA
Database	SQLite + msgpackr	Null nettverksforsinkelse, optimalisert serialisering
Maskinvare	AMD Ryzen bare metal	Ingen virtualiseringskostnader
Caching	I minnet + vedvarende	Respons under millisekundet
Sikkerhetskopier	Cloudflare R2 kryptert	Bedriftsnivå pålitelighet

Reelle ytelsestall:

API-responstid: < 50 ms i gjennomsnitt
Meldingshenting: < 10 ms for bufrede meldinger
Mappeoperasjoner: < 5 ms for metadataoperasjoner
Kontakt-synkronisering: 1000+ kontakter/sekund
Oppetid: 99,99 % SLA med redundant infrastruktur

Personvern-først arkitektur

Null-kunnskap design: Kun du har tilgang med ditt IMAP-passord – vi kan ikke lese e-postene dine. Vår null-kunnskap arkitektur sikrer fullstendig personvern samtidig som den leverer lynrask ytelse.

Hvorfor vi er annerledes: Den komplette sammenligningen

Store leverandørbegrensninger

Leverandør	Kjerneproblemer	Spesifikke begrensninger
Gmail API	Kun lesetilgang, Kompleks OAuth, Separate API-er	• Kan ikke endre eksisterende meldinger • Etiketter ≠ mapper • 1 milliard kvoteenheter/dag grense • Krever separate API-er for kontakter/kalender
Outlook API	Utdatert, Forvirrende, Enterprise-fokusert	• REST-endepunkter utgått mars 2024 • Flere forvirrende API-er (EWS, Graph, REST) • Microsoft Graph kompleksitet • Aggressiv throttling
Apple iCloud	Ingen offentlig API	• Ingen offentlig API overhodet • Kun IMAP med 1000 e-poster/dag grense • App-spesifikke passord kreves • 500 mottakere per melding grense
ProtonMail	Ingen API, Falske åpen kildekode-påstander	• Ingen offentlig API tilgjengelig • Bridge-programvare kreves for IMAP-tilgang • Påstår "åpen kildekode" men serverkoden er proprietær • Begrenset til betalte planer
Tuta	Ingen API, Misvisende åpenhet	• Ingen REST API for e-posthåndtering • Påstår "åpen kildekode" men backend er lukket • IMAP/SMTP ikke støttet • Proprietær kryptering hindrer standardintegrasjoner
Zapier Email	Strenge hastighetsbegrensninger	• 10 e-poster per time grense • Ingen IMAP-mappe-tilgang • Begrensede parsing-muligheter

Fordeler med videresending av e-post

Funksjon	Videresending av e-post	Konkurrenter
Full CRUD	✅ Full opprettelse, lesing, oppdatering, sletting for alle data	❌ Kun lesing eller begrensede operasjoner
Enhetlig API	✅ Meldinger, mapper, kontakter, kalendere i ett API	❌ Separate API-er eller manglende funksjoner
Enkel autentisering	✅ Enkel autentisering med alias-legitimasjon	❌ Kompleks OAuth med flere tillatelser
Ingen hastighetsbegrensninger	✅ Generøse grenser designet for reelle applikasjoner	❌ Restriktive kvoter som bryter arbeidsflyt
Selvhosting	✅ Fullstendig selvhosting-alternativ	❌ Kun leverandørlåsning
Personvern	✅ Null-kunnskap, kryptert, privat	❌ Datainnsamling og personvernproblemer
Ytelse	✅ Under 50 ms responstid, NVMe-lagring	❌ Nettverksforsinkelser, struping

Problemet med åpen kildekode og gjennomsiktighet

ProtonMail og Tuta markedsfører seg som "åpen kildekode" og "gjennomsiktige," men dette er misvisende markedsføring som bryter med moderne personvernprinsipper.

Warning

Falske påstander om gjennomsiktighet: Både ProtonMail og Tuta reklamerer sterkt med sine "åpen kildekode"-kvalifikasjoner samtidig som de holder sin mest kritiske serverkode proprietær og lukket.

ProtonMails bedrag:

Påstander: "Vi er åpen kildekode" fremhevet i markedsføring
Virkelighet: Serverkoden er helt proprietær – kun klientapper er åpen kildekode
Konsekvens: Brukere kan ikke verifisere server-side kryptering, databehandling eller personvernpåstander
Brudd på gjennomsiktighet: Ingen mulighet til å revidere de faktiske e-postbehandlings- og lagringssystemene

Tutas misvisende markedsføring:

Påstander: "Åpen kildekode e-post" som et kjernepunkt
Virkelighet: Backend-infrastrukturen er lukket kildekode – kun frontend er tilgjengelig
Konsekvens: Proprietær kryptering hindrer standard e-postprotokoller (IMAP/SMTP)
Låsestrategi: Egendefinert kryptering tvinger leverandørafhengighet

Hvorfor dette er viktig for moderne personvern:

I 2025 krever ekte personvern fullstendig gjennomsiktighet. Når e-postleverandører hevder "åpen kildekode" men skjuler serverkoden:

Uverifiserbar kryptering: Du kan ikke revidere hvordan dataene dine faktisk krypteres
Skjulte dataprosesser: Server-side databehandling forblir en svart boks
Tillitsbasert sikkerhet: Du må stole på påstandene uten verifisering
Leverandørlåsning: Proprietære systemer hindrer dataportabilitet

Forward Emails ekte gjennomsiktighet:

✅ Fullstendig åpen kildekode – server- og klientkode
✅ Selvhosting tilgjengelig – kjør din egen instans
✅ Standardprotokoller – IMAP, SMTP, CardDAV, CalDAV-kompatibilitet
✅ Reviderbar sikkerhet – hver kodelinje kan inspiseres
✅ Ingen leverandørlåsning – dine data, din kontroll

Tip

Ekte åpen kildekode betyr at du kan verifisere hver påstand. Med Forward Email kan du revidere vår kryptering, gjennomgå vår databehandling, og til og med kjøre din egen instans. Det er ekte gjennomsiktighet.

30+ ekte integrasjonseksempler

1. Forbedring av WordPress kontaktskjema

Problem: WordPress SMTP-konfigurasjonsfeil (631 GitHub-issues) Løsning: Direkte API-integrasjon omgår SMTP helt

// WordPress kontaktskjema som lagrer til 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: 'Kontaktskjema: ' + formData.subject,
    text: formData.message,
    folder: 'Sent'
  })
});

2. Zapier-alternativ for e-postautomatisering

Problem: Zapiers grense på 10 e-poster/time og IMAP-deteksjonsfeil Løsning: Ubegrenset automatisering med full e-postkontroll

// Auto-organiser e-poster etter avsenderdomene
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-postsynkronisering

Problem: Manuell kontaktadministrasjon mellom e-post og CRM-systemer Løsning: To-veis synkronisering med CardDAV kontakt-API

// Synkroniser nye e-postkontakter 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: Manuell ordrebehandling av e-post for e-handelsplattformer Løsning: Automatisert ordrebehandlingspipeline

// Behandle ordrebekreftelses-e-poster
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. Support-sak-integrasjon

Problem: E-posttråder spredt over helpdesk-plattformer Løsning: Fullstendig sporing av e-posttråder

// Opprett supportsak fra e-posttrå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
  });
}

Problem: Begrensede integrasjoner med nyhetsbrevsplattformer Løsning: Fullstendig administrasjon av abonnenters livssyklus

// Automatisk administrasjon av nyhetsbrevsabonnementer
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-postbasert oppgavehåndtering

Problem: Overveldende innboks og oppgaveoppfølging Løsning: Konverter e-poster til handlingsbare oppgaver

// 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. E-postsikkerhetskopiering og samsvar

Problem: E-postlagring og samsvarskrav
Løsning: Automatisk sikkerhetskopiering med bevaring av metadata

// Sikkerhetskopier e-poster med full metadata
const allMessages = await fetch('/v1/messages');
const backup = {
  timestamp: new Date(),
  messages: allMessages.map(msg => ({
    id: msg.id,
    subject: msg.subject,
    from: msg.from,
    to: msg.to,
    date: msg.date,
    flags: msg.flags
  }))
};
await saveToComplianceStorage(backup);

13. E-postbasert innholdsstyring

Problem: Håndtering av innholdsendringer via e-post for CMS-plattformer
Løsning: E-post som innholdsstyringssystem

// Behandle innholdsendringer fra e-post
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-postmaladministrasjon

Problem: Uensartede e-postmaler i teamet
Løsning: Sentralisert mal-system med API

// Send e-poster med mal og dynamisk innhold
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-postbasert arbeidsflytautomatisering

Problem: Manuelle godkjenningsprosesser via e-post
Løsning: Automatiserte arbeidsflytutløsere

// Behandle godkjennings-e-poster
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-postsikkerhetsovervåking

Problem: Manuell trusseldeteksjon
Løsning: Automatisk trusselanalyse

// Overvåk mistenkelige e-poster
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-postbasert undersøkelsessamling

Problem: Manuell behandling av undersøkelsessvar
Løsning: Automatisk responsaggregasjon

// Samle inn og behandle undersøkelsessvar
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-postytelsesovervåking

Problem: Manglende innsikt i e-postleveringsytelse
Løsning: E-poststatistikk i sanntid

// Overvåk e-postleveringsytelse
const sentEmails = await fetch('/v1/messages?folder=Sent');
const deliveryStats = {
  sent: sentEmails.length,
  bounces: await countBounces(),
  deliveryRate: calculateDeliveryRate()
};
await updateDashboard(deliveryStats);

19. E-postbasert lead-kvalifisering

Problem: Manuell lead scoring fra e-postinteraksjoner
Løsning: Automatisert lead-kvalifiseringspipeline

// Score leads basert på e-postengasjement
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-postbasert prosjektstyring

Problem: Prosjektoppdateringer spredt over e-posttråder
Løsning: Sentralisert kommunikasjonsnav for prosjekter

// Hent prosjektoppdateringer fra e-poster
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-postbasert lagerstyring

Problem: Manuelle lageroppdateringer fra leverandøre-poster
Løsning: Automatisert lageroppfølging fra e-postvarsler

// Behandle lageroppdateringer fra leverandøre-poster
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
  });

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

22. E-postbasert fakturabehandling

Problem: Manuell fakturabehandling og regnskapsintegrasjon
Løsning: Automatisert fakturauttrekk og synkronisering med regnskapssystem

// Hent fakturadata fra e-postvedlegg
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
  });

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

23. E-postbasert påmelding til arrangement

Problem: Manuell påmelding til arrangement fra e-postsvar
Løsning: Automatisert deltakerhåndtering og kalenderintegrasjon

// Behandle påmeldings-e-poster til arrangement
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);

  // Legg til i deltakerlisten
  await events.addAttendee({
    event: attendeeData.eventId,
    name: attendeeData.name,
    email: registration.from,
    dietary: attendeeData.dietaryRestrictions
  });

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

24. E-postbasert dokumentgodkjenningsflyt

Problem: Komplekse dokumentgodkjennings-kjeder via e-post
Løsning: Automatisert sporing av godkjenning og dokumentversjonering

// 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-postbasert analyse av kundetilbakemeldinger

Problem: Manuell innsamling av kundetilbakemeldinger og sentimentanalyse
Løsning: Automatisert behandling av tilbakemeldinger og sporing av sentiment

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

Problem: Manuell rekruttering og kandidatsporing
Løsning: Automatisert kandidatbehandling og intervjuscheduling

// 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-postbasert behandling av utgiftsrapporter

Problem: Manuell innsending og godkjenning av utgiftsrapporter
Løsning: Automatisert utgiftsuttrekking og godkjenningsflyt

// 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-postbasert kvalitetskontrollrapportering

Problem: Manuell kvalitetssikring feilsporing
Løsning: Automatisert QA-feilhåndtering og feilsporing

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

Problem: Manuell leverandørkommunikasjon og kontraktssporing
Løsning: Automatisert leverandørrelasjonsstyring

// 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: `Gjennomgå kontraktskommunikasjon fra ${vendor.name}`,
      assignee: 'procurement@company.com',
      dueDate: addDays(new Date(), 2)
    });
  }
}

Problem: Manuell sosiale medier omtalesporing og respons
Løsning: Automatisert behandling av sosiale medier-varsler og koordinering av respons

// 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: `Haster: Svar på negativ omtale i sosiale medier`,
        start: addMinutes(new Date(), 30),
        attendees: ['social-media-manager@company.com']
      })
    });
  }
}

Komme i gang

1. Opprett din videresendings-e-postkonto

Registrer deg på forwardemail.net og verifiser domenet ditt.

2. Generer API-legitimasjon

Din alias-e-post og passord fungerer som API-legitimasjon – ingen ekstra oppsett kreves.

3. Gjør ditt første API-kall

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

# Opprett 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. Utforsk dokumentasjonen

Besøk forwardemail.net/en/email-api for komplett API-dokumentasjon med interaktive eksempler.

Tekniske ressurser

Komplett API-dokumentasjon - Interaktiv OpenAPI 3.0-spesifikasjon
Veiledning for selvhosting - Distribuer Forward Email på din infrastruktur
Sikkerhets-whitepaper - Teknisk arkitektur og sikkerhetsdetaljer
GitHub-repositorium - Åpen kildekode
Utviklerstøtte - Direkte tilgang til vårt ingeniørteam

Klar til å revolusjonere e-postintegrasjonen din? Begynn å bygge med Forward Emails API i dag og opplev den første komplette e-postadministrasjonsplattformen designet for utviklere.

Forward Email: E-posttjenesten som endelig får API-er riktig.