Det første komplette e-post-API-et: Hvordan videresendt e-post revolusjonerte e-posthåndtering

TL;DR: Vi bygde verdens første komplette REST API for e-postadministrasjon med avanserte søkefunksjoner som ingen andre tjenester tilbyr. Mens Gmail, Outlook og Apple tvinger utviklere inn i IMAP-helvete eller hastighetsbegrensede API-er, leverer Forward Email lynraske CRUD-operasjoner for meldinger, mapper, kontakter og kalendere gjennom et enhetlig REST-grensesnitt med over 15 søkeparametere. Dette er e-post-API-utviklerne har ventet på.

Problemet med e-post-API-et

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

Alle større e-postleverandører tvinger utviklere til ett av to forferdelige valg:

  1. IMAP-helvete: Bryting med en 30 år gammel protokoll designet for skrivebordsklienter, ikke moderne applikasjoner
  2. Forkrøplede API-er: Hastighetsbegrensede, skrivebeskyttede, OAuth-komplekse API-er som ikke kan administrere dine faktiske e-postdata

Resultatet? Utviklere enten forlater e-postintegrasjon helt eller kaster bort uker på å bygge skjøre IMAP-innpakninger som stadig vekk går i stykker.

Warning

Den skitne hemmeligheten: De fleste «e-post-API-er» er bare sendende API-er. Du kan ikke programmatisk organisere mapper, synkronisere kontakter eller administrere kalendere via et enkelt REST-grensesnitt. Før nå.

Hva utviklere faktisk sier

Frustrasjonen er reell og dokumentert overalt:

«Jeg prøvde nylig å integrere Gmail i appen min, og jeg brukte for 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-API-er middelmådige? De virker begrensede eller restriktive på en eller annen måte."

- Reddit r/SaaS-diskusjon

"Hvorfor må e-postutvikling være dårlig?"

- Reddit r/webdev, 89 kommentarer om utviklersmerte

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

- Spørsmål om Stack Overflow med 47 oppstemmer

Bevisene er overalt:

  • WordPress SMTP-problemer: 631 GitHub-problemer om leveringsfeil i e-post
  • Zapier-begrensninger: Klager fra lokalsamfunnet om grenser for 10 e-poster/time og feil i IMAP-deteksjon
  • IMAP API-prosjekter: Flere åpen kildekode prosjekter eksisterer spesifikt for å "konvertere IMAP til REST" fordi ingen leverandører tilbyr dette
  • Frustrasjoner med Gmail API: Stack Overflow har 4847 spørsmål merket med "gmail-api" med vanlige klager om hastighetsgrenser og kompleksitet

Den revolusjonerende løsningen for videresending av e-post

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

Dette er ikke bare enda et sendende API. Dette er fullstendig programmatisk kontroll over:

  • Meldinger: Opprett, les, oppdater, slett, søk, flytt, flagg
  • Mapper: Full IMAP-mappeadministrasjon via REST-endepunkter
  • Kontakter: CardDAV kontaktlagring og synkronisering
  • Kalendere: CalDAV kalenderhendelser og planlegging

Hvorfor vi bygde dette

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

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

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

Enkel autentisering

Ingen OAuth-kompleksitet. Ingen appspesifikke passord. Bare alias-legitimasjonen din:

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

20 endepunkter som forandrer 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, lesestatus)
  • DELETE /v1/messages/:id - Slett melding permanent

Mapper (5 endepunkter)

  • GET /v1/folders – List opp alle mapper med abonnementsstatus
  • POST /v1/folders – Opprett ny mappe med tilpassede egenskaper
  • GET /v1/folders/:id – Hent mappedetaljer og antall meldinger
  • PUT /v1/folders/:id – Oppdater mappeegenskaper og abonnement
  • DELETE /v1/folders/:id – Slett mappe og håndter flytting av meldinger

Kontakter (5 endepunkter)

  • GET /v1/contacts - Liste over 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 opp kalenderhendelser med datofiltrering
  • POST /v1/calendars - Opprett kalenderhendelse med deltakere og regelmessighet
  • GET /v1/calendars/:id - Hent hendelsesdetaljer med tidssonehåndtering
  • PUT /v1/calendars/:id - Oppdater hendelse med konfliktdeteksjon
  • DELETE /v1/calendars/:id - Slett hendelse med deltakervarsler

Avansert søk: Ingen annen tjeneste kan sammenlignes

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

Mens andre leverandører i beste fall tilbyr grunnleggende filtrering, har vi bygget det mest avanserte API-et for e-postsøk 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 for søk i Gmail API:

  • ✅ Kun grunnleggende q-parameter
  • ❌ Ingen feltspesifikk søk
  • ❌ Ingen filtrering av datointervall
  • ❌ Ingen størrelsesbasert filtrering
  • ❌ Ingen filtrering av vedlegg
  • ❌ Begrenset til Gmails søkesyntaks

Begrensninger for søk i Outlook API:

  • ✅ Grunnleggende $search-parameter
  • ❌ Ingen avansert feltmålretting
  • ❌ Ingen komplekse spørrekombinasjoner
  • ❌ Aggressiv hastighetsbegrensning
  • ❌ Kompleks OData-syntaks kreves

Apple iCloud:

  • ❌ Ingen API overhodet
  • ❌ Kun IMAP-søk (hvis du får det til å fungere)

ProtonMail og Tuta:

  • ❌ Ingen offentlige API-er
  • ❌ Ingen programmatiske søkemuligheter

Videresend e-posts revolusjonerende søke-API

Vi tilbyr over 15 søkeparametere som ingen annen tjeneste tilbyr:

Søkefunksjon Videresend e-post Gmail API Outlook API Andre
Feltspesifikt søk ✅ Emne, brødtekst, fra, til, kopi, overskrifter ❌ ❌ ❌
Generelt søk i flere felt ✅ ?search= på tvers av alle felt ✅ Grunnleggende q= ✅ Grunnleggende $search= ❌
Filtrering av datoperiode ✅ ?since= & ?before= ❌ ❌ ❌
Størrelsesbasert filtrering ✅ ?min_size= & ?max_size= ❌ ❌ ❌
Filtrering av vedlegg ✅ ?has_attachments=true/false ❌ ❌ ❌
Søk i overskrift ✅ ?headers=X-Priority ❌ ❌ ❌
Søk etter meldings-ID ✅ ?message_id=abc123 ❌ ❌ ❌
Kombinerte filtre ✅ Flere parametere med AND-logikk ❌ ❌ ❌
Uavhengig av store og små bokstaver ✅ Alle søk ✅ ✅ ❌
Støtte for paginering ✅ Fungerer med alle søkeparametere ✅ ✅ ❌

Eksempler på søk fra den virkelige verden

Finn alle fakturaer fra forrige kvartal:

# 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

Søk etter store vedlegg fra en bestemt avsender:

# 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

Komplekst flerfeltssøk:

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

Ytelsesfordeler

Ytelse for søk etter videresending av e-post:

  • ⚡ Responstider under 100 ms for komplekse søk
  • 🔍 Regex-optimalisering med riktig indeksering
  • 📊 Parallell spørreutførelse for antall og data
  • 💾 Effektiv minnebruk med lean-spørringer

Problemer med konkurrentenes ytelse:

  • 🐌 Gmail API: Hastigheten er begrenset til 250 kvoteenheter per bruker per sekund
  • 🐌 Outlook API: Aggressiv begrensning med komplekse krav til tilbakekalling
  • 🐌 Andre: Ingen API-er å sammenligne mot

Søkefunksjoner ingen andre har

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

2. Størrelsesbasert intelligens

# 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. Vedleggsbaserte arbeidsflyter

# 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. Kombinert forretningslogikk

# Find urgent flagged messages from VIPs with attachments
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:

  1. Avansert e-postanalyse: Analyser e-postmønstre etter størrelse, avsender og innhold
  2. Intelligent e-postadministrasjon: Organiser automatisk basert på komplekse kriterier
  3. Samsvar og oppdagelse: Finn spesifikke e-poster for juridiske krav
  4. Forretningsintelligens: Hent ut innsikt fra e-postkommunikasjonsmønstre
  5. Automatiserte arbeidsflyter: Utløs handlinger basert på sofistikerte e-postfiltre

Den tekniske implementeringen

Vårt søke-API bruker:

  • Regex-optimalisering med riktige indekseringsstrategier
  • Parallell utførelse for ytelse
  • Inputvalidering for sikkerhet
  • Omfattende feilhåndtering for pålitelighet
// 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

Fordel for utviklere: Med søke-API-et for Forward Email kan du bygge e-postprogrammer som kan konkurrere med skrivebordsklienter i funksjonalitet, samtidig som du beholder enkelheten til REST API-er.

Lynrask ytelsesarkitektur

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

Ytelsesbenchmarks

Hvorfor vi er lynraske:

Komponent Teknologi Ytelsesfordel
Lagring NVMe SSD 10 ganger raskere enn tradisjonell SATA
Database SQLite + msgpackr Null nettverksforsinkelse, optimalisert serialisering
Maskinvare AMD Ryzen bart metall Ingen virtualiseringsoverhead
Bufring I minnet + vedvarende Responstider på under et millisekund
Sikkerhetskopier Cloudflare R2 kryptert Pålitelighet i bedriftsklasse

Reelle ytelsestall:

  • API-responstid: < 50 ms gjennomsnitt
  • Meldingshenting: < 10 ms for hurtigbufrede meldinger
  • Mappeoperasjoner: < 5 ms for metadataoperasjoner
  • Kontaktsynkronisering: 1000+ kontakter/sekund
  • Oppetid: 99,99 % tjenestenivåavtale med redundant infrastruktur

Personvern-først-arkitektur

Nullkunnskapsdesign: Bare du har tilgang med IMAP-passordet ditt – vi kan ikke lese e-postene dine. Vår nullkunnskapsarkitektur sikrer fullstendig personvern samtidig som den leverer lynrask ytelse.

Hvorfor vi er forskjellige: Den komplette sammenligningen

Viktige leverandørbegrensninger

Leverandør Kjerneproblemer Spesifikke begrensninger
Gmail API Skrivebeskyttet, kompleks OAuth, separate API-er • Cannot modify existing messages
• Labels ≠ folders
• 1 billion quota units/day limit
• Requires separate APIs for kontakter/kalender
Outlook API Utdatert, forvirrende, bedriftsfokusert • REST endpoints deprecated March 2024
• Multiple confusing APIs (EWS, graf, REST)
• Microsoft Graph complexity
• Aggressive throttling
Apple iCloud Ingen offentlig API • No public API whatsoever
• IMAP-only with 1000 emails/day limit
• App-specific passwords required
• 500 recipients per message limit
ProtonMail Ingen API, falske påstander om åpen kildekode • No public API available
• Bridge software required for IMAP-tilgang
• Claims "open source" men server code is proprietary
• Limited to paid plans only
Total Ingen API, villedende åpenhet • No REST API for email management
• Claims "open source" men backend is closed
• IMAP/SMTP not supported
• Proprietary encryption forhindrer standardintegrasjoner
Zapier-e-post Alvorlige hastighetsgrenser • 10 emails per hour limit
• No IMAP folder access
• Limited parsing capabilities

Fordeler med videresending av e-post

Trekk Videresend e-post Konkurranse
Helt KRUT ✅ Fullstendig oppretting, lesing, oppdatering og sletting av alle data ❌ Skrivebeskyttet eller begrensede operasjoner
Enhetlig API ✅ Meldinger, mapper, kontakter, kalendere i ett API ❌ Separate API-er eller manglende funksjoner
Enkel autentisering ✅ Grunnleggende autentisering med alias-legitimasjon ❌ Kompleks OAuth med flere omfang
Ingen prisgrenser ✅ Sjenerøse grenser designet for reelle applikasjoner ❌ Restriktive kvoter som forstyrrer arbeidsflyter
Selvhosting ✅ Complete self-hosting option ❌ Kun leverandørlåsing
Privatliv ✅ Nullkunnskap, kryptert, privat ❌ Datautvinning og bekymringer om personvern
Ytelse ✅ Responstider under 50 ms, NVMe-lagring ❌ Nettverksforsinkelse, forsinkelser i begrensninger

Problemet med åpen kildekode-transparens

ProtonMail og Tuta markedsfører seg selv som «åpen kildekode» og «transparente», men dette er villedende markedsføring som bryter med moderne personvernprinsipper.

Warning

Falske påstander om åpenhet: Både ProtonMail og Tuta reklamerer tydelig for sine «åpen kildekode»-legitimasjoner, samtidig som de holder den viktigste serversidekoden sin proprietær og lukket.

ProtonMails bedrag:

  • Påstander: "Vi er åpen kildekode" fremtredende omtalt i markedsføring
  • Realitet: Serverkoden er fullstendig proprietær - bare klientapper er åpen kildekode
  • Virkning: Brukere kan ikke bekrefte kryptering på serversiden, datahåndtering eller personvernkrav
  • Brudd på åpenhet: Ingen måte å revidere de faktiske systemene for e-postbehandling og lagring

Tutas villedende markedsføring:

Hvorfor dette er viktig for moderne personvern:

I 2025 krever ekte personvern fullstendig åpenhet. Når e-postleverandører hevder å være «åpen kildekode», men skjuler serverkoden sin:

  1. Uverifiserbar kryptering: Du kan ikke revidere hvordan dataene dine faktisk er kryptert
  2. Skjult datapraksis: Datahåndtering på serversiden er fortsatt en svart boks
  3. Tillitsbasert sikkerhet: Du må stole på påstandene deres uten verifisering
  4. Leverandørlåsing: Proprietære systemer forhindrer dataportabilitet

Videresendt e-posts ekte åpenhet:

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

Tip

Ekte åpen kildekode betyr at du kan bekrefte alle påstander. Med Videresendt e-post kan du revidere krypteringen vår, gjennomgå datahåndteringen vår og til og med kjøre din egen instans. Det er ekte åpenhet.

30+ eksempler på integrasjon fra den virkelige verden

1. Forbedring av WordPress-kontaktskjema

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

// WordPress contact form that saves to Sent folder
await fetch('https://api.forwardemail.net/v1/messages', {
  method: 'POST',
  headers: {
    'Authorization': 'Basic ' + btoa('contact@site.com:password'),
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    to: [{ address: 'owner@site.com' }],
    subject: 'Contact Form: ' + formData.subject,
    text: formData.message,
    folder: 'Sent'
  })
});

2. Zapier-alternativ for e-postautomatisering

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

// Auto-organize emails by sender domain
const messages = await fetch('/v1/messages?folder=INBOX');
for (const message of messages) {
  const domain = message.from.split('@')[1];
  await fetch(`/v1/messages/${message.id}`, {
    method: 'PUT',
    body: JSON.stringify({ folder: `Clients/${domain}` })
  });
}

3. CRM-e-postsynkronisering

Problem: Manuell kontakthåndtering mellom e-post og CRM-systemer Løsning: Toveis synkronisering med CardDAV kontakt-API

// Sync new email contacts to CRM
const newContacts = await fetch('/v1/contacts');
for (const contact of newContacts) {
  await crmAPI.createContact({
    name: contact.name,
    email: contact.email,
    source: 'email_api'
  });
}

4. Behandling av e-handelsordrer

Problem: Manuell behandling av bestillings-e-post for e-handelsplattformer Løsning: Automatisert ordrebehandlingsprosess

// Process order confirmation emails
const orders = await fetch('/v1/messages?folder=Orders');
const orderEmails = orders.filter(msg =>
  msg.subject.includes('Order Confirmation')
);

for (const order of orderEmails) {
  const orderData = parseOrderEmail(order.text);
  await updateInventory(orderData);
  await fetch(`/v1/messages/${order.id}`, {
    method: 'PUT',
    body: JSON.stringify({ folder: 'Orders/Processed' })
  });
}

5. Støtte for integrering av billett

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

// Create support ticket from email thread
const messages = await fetch('/v1/messages?folder=Support');
const supportEmails = messages.filter(msg =>
  msg.to.some(addr => addr.includes('support@'))
);

for (const email of supportEmails) {
  const ticket = await supportSystem.createTicket({
    subject: email.subject,
    from: email.from,
    body: email.text,
    timestamp: email.date
  });
}

6. System for nyhetsbrevhåndtering

Problem: Begrensede nyhetsbrevplattform-integrasjoner Løsning: Fullstendig administrasjon av abonnentens livssyklus

// Auto-manage newsletter subscriptions
const messages = await fetch('/v1/messages?folder=Newsletter');
const unsubscribes = messages.filter(msg =>
  msg.subject.toLowerCase().includes('unsubscribe')
);

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

7. E-postbasert oppgavebehandling

Problem: Overfylt innboks og oppgavesporing Løsning: Konverter e-poster til handlingsrettede 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. E-postaggregering for flere kontoer

Problem: Administrering av flere e-postkontoer på tvers av leverandører Løsning: Enhetlig innboksgrensesnitt

// 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. Avansert dashbord for e-postanalyse

Problem: Ingen innsikt i e-postmønstre med sofistikert filtrering Løsning: Tilpasset e-postanalyse ved hjelp av avanserte søkefunksjoner

// 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 e-postarkivering

Problem: Manuell e-postorganisasjon Løsning: Intelligent e-postkategorisering

// 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. Integrering av e-post til kalender

Problem: Manuell oppretting av kalenderhendelse fra e-poster Løsning: Automatisk uttrekking og oppretting av hendelser

// 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. Sikkerhetskopiering og samsvar med e-post

Problem: E-postoppbevaring og samsvarskrav Løsning: Automatisert sikkerhetskopiering med bevaring av metadata

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

13. E-postbasert innholdshåndtering

Problem: Administrering av innholdsinnsendinger via e-post for CMS-plattformer Løsning: E-post som innholdsstyringssystem

// 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. Administrasjon av e-postmaler

Problem: Inkonsekvent e-postmaler på tvers av teamet Løsning: Sentralisert malsystem 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. E-postbasert arbeidsflytautomatisering

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

// 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. Overvåking av e-postsikkerhet

Problem: Manuell deteksjon av sikkerhetstrusler Løsning: Automatisert 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. E-postbasert undersøkelsesinnsamling

Problem: Manuell svar på undersøkelsen-behandling Løsning: Automatisert svaraggregering

// 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. Overvåking av e-postytelse

Problem: Ingen innsyn i e-postleveringsytelse Løsning: E-postmålinger i sanntid

// Monitor email delivery performance
const sentEmails = await fetch('/v1/messages?folder=Sent');
const deliveryStats = {
  sent: sentEmails.length,
  bounces: await countBounces(),
  deliveryRate: calculateDeliveryRate()
};
await updateDashboard(deliveryStats);

19. E-postbasert potensiell kvalifisering

Problem: Manuell poengsum fra e-postinteraksjoner Løsning: Automatisert pipeline for kvalifisering av potensielle kunder

// Score leads based on email engagement
const prospects = await fetch('/v1/contacts');
for (const prospect of prospects) {
  const messages = await fetch('/v1/messages');
  const emails = messages.filter(msg =>
    msg.from.includes(prospect.email)
  );
  const score = calculateEngagementScore(emails);
  await crm.updateLeadScore(prospect.id, score);
}

20. E-postbasert prosjektstyring

Problem: Prosjektoppdateringer spredt på tvers av e-posttråder Løsning: Sentralisert prosjektkommunikasjonssenter

// Extract project updates from emails
const messages = await fetch('/v1/messages?folder=Projects');
const projectEmails = messages.filter(msg =>
  msg.subject.includes('Project Update')
);

for (const email of projectEmails) {
  const update = parseProjectUpdate(email.text);
  await projectManager.addUpdate({
    project: update.projectId,
    author: email.from,
    content: update.content
  });
}

21. E-postbasert lagerstyring

Problem: Manuelle lageroppdateringer fra leverandørens e-poster Løsning: Automatisert lagersporing fra e-postvarsler

// Process inventory updates from supplier emails
const messages = await fetch('/v1/messages?folder=Suppliers');
const inventoryEmails = messages.filter(msg =>
  msg.subject.includes('Inventory Update') || msg.subject.includes('Stock Alert')
);

for (const email of inventoryEmails) {
  const inventoryData = parseInventoryUpdate(email.text);
  await inventory.updateStock({
    sku: inventoryData.sku,
    quantity: inventoryData.quantity,
    supplier: email.from,
    timestamp: email.date
  });

  // Move to processed folder
  await fetch(`/v1/messages/${email.id}`, {
    method: 'PUT',
    body: JSON.stringify({ folder: 'Suppliers/Processed' })
  });
}

22. E-postbasert fakturabehandling

Problem: Manuell fakturabehandling og regnskapsintegrasjon Løsning: Automatisk fakturauttrekking og synkronisering av regnskapssystem

// Extract invoice data from email attachments
const messages = await fetch('/v1/messages?folder=Invoices');
const invoiceEmails = messages.filter(msg =>
  msg.subject.toLowerCase().includes('invoice') && msg.attachments.length > 0
);

for (const email of invoiceEmails) {
  const invoiceData = await extractInvoiceData(email.attachments[0]);
  await accounting.createInvoice({
    vendor: email.from,
    amount: invoiceData.total,
    dueDate: invoiceData.dueDate,
    items: invoiceData.lineItems
  });

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

23. E-postbasert arrangementsregistrering

Problem: Manuell arrangementsregistrering-behandling fra e-postsvar Løsning: Automatisert deltakeradministrasjon og kalenderintegrasjon

// Process event registration emails
const messages = await fetch('/v1/messages?folder=Events');
const registrations = messages.filter(msg =>
  msg.subject.includes('Registration') || msg.subject.includes('RSVP')
);

for (const registration of registrations) {
  const attendeeData = parseRegistration(registration.text);

  // Add to attendee list
  await events.addAttendee({
    event: attendeeData.eventId,
    name: attendeeData.name,
    email: registration.from,
    dietary: attendeeData.dietaryRestrictions
  });

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

24. E-postbasert arbeidsflyt for dokumentgodkjenning

Problem: Komplekse dokumentgodkjenning-kjeder via e-post Løsning: Automatisert godkjenningssporing og dokumentversjonskontroll

// 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 tilbakemeldinger fra kunder-innsamling og sentimentanalyse Løsning: Automatisert tilbakemeldingsbehandling 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-postbasert rekrutteringsprosess

Problem: Manuell rekruttering og kandidatsporing Løsning: Automatisert kandidatadministrasjon og intervjuplanlegging

// 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 utgiftsrapport Løsning: Automatisert arbeidsflyt for uttrekk og godkjenning av utgifter

// 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 kvalitetssikringsrapportering

Problem: Manuell kvalitetssikring problemsporing Løsning: Automatisert problemhåndtering og feilsporing for kvalitetssikring

// 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øradministrasjon

Problem: Manuell leverandørkommunikasjon og kontraktssporing Løsning: Automatisert håndtering av leverandørrelasjoner

// 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-postbasert overvåking av sosiale medier

Problem: Manuell sporing og respons av sosiale medier-omtaler Løsning: Automatisert behandling av varsler på sosiale medier og koordinering av responser

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

Komme i gang

1. Opprett din videresendingskonto for e-post

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

2. Generer API-legitimasjon

Alias-e-postadressen og passordet ditt fungerer som API-legitimasjon – ingen ytterligere oppsett kreves.

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

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

# Create a new contact
curl -u "your-alias@domain.com:password" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"fullName":"John Doe","emails":[{"value":"john@example.com"}]}' \
  https://api.forwardemail.net/v1/contacts

4. Utforsk dokumentasjonen

Gå til forwardemail.net/en/email-api for fullstendig API-dokumentasjon med interaktive eksempler.

Tekniske ressurser

Klar til å revolusjonere e-postintegrasjonen din? Begynn å bygge med API-et for videresendt e-post i dag og opplev den første komplette e-postadministrasjonsplattformen som er utviklet for utviklere.

Videresend e-post: E-posttjenesten som endelig får API-ene riktige.