Daftar Isi

API Email Lengkap Pertama: Bagaimana Forward Email Merevolusi Manajemen Email

Complete email API with IMAP CardDAV CalDAV REST

TL;DR: Kami membangun REST API lengkap pertama di dunia untuk manajemen email dengan kemampuan pencarian canggih yang tidak ditawarkan layanan lain. Sementara Gmail, Outlook, dan Apple memaksa pengembang ke dalam neraka IMAP atau API dengan batasan kecepatan, Forward Email menghadirkan operasi CRUD yang sangat cepat untuk pesan, folder, kontak, dan kalender melalui antarmuka REST terpadu dengan lebih dari 15 parameter pencarian. Ini adalah API email yang telah lama ditunggu oleh para pengembang.

Masalah API Email

API email pada dasarnya rusak. Titik.

Setiap penyedia email besar memaksa pengembang memilih salah satu dari dua pilihan buruk:

Neraka IMAP: Berjuang dengan protokol berusia 30 tahun yang dirancang untuk klien desktop, bukan aplikasi modern
API Terbatas: API yang dibatasi kecepatan, hanya baca, dan kompleksitas OAuth yang tidak bisa mengelola data email Anda secara nyata

Hasilnya? Pengembang entah meninggalkan integrasi email sepenuhnya atau membuang waktu berminggu-minggu membangun pembungkus IMAP yang rapuh dan sering rusak.

Warning

Rahasia Kotor: Sebagian besar "API email" hanyalah API pengiriman. Anda tidak bisa secara programatik mengatur folder, menyinkronkan kontak, atau mengelola kalender melalui antarmuka REST sederhana. Sampai sekarang.

Apa yang Sebenarnya Dikatakan Pengembang

Frustrasi itu nyata dan terdokumentasi di mana-mana:

"Saya baru-baru ini mencoba mengintegrasikan Gmail di aplikasi saya, dan saya menghabiskan terlalu banyak waktu untuk itu. Saya memutuskan tidak layak untuk mendukung Gmail."

- Pengembang Hacker News, 147 suara suka

"Apakah semua API email biasa-biasa saja? Mereka tampak terbatas atau membatasi dalam beberapa hal."

- Diskusi Reddit r/SaaS

"Kenapa pengembangan email harus menyebalkan?"

- Reddit r/webdev, 89 komentar tentang kesulitan pengembang

"Apa yang membuat API Gmail lebih efisien daripada IMAP? Alasan lain API Gmail jauh lebih efisien adalah karena hanya perlu mengunduh setiap pesan sekali saja. Dengan IMAP, setiap pesan harus diunduh dan diindeks..."

- Pertanyaan Stack Overflow dengan 47 suara suka

Buktinya ada di mana-mana:

Masalah SMTP WordPress: 631 isu GitHub tentang kegagalan pengiriman email
Batasan Zapier: Keluhan komunitas tentang batas 10 email/jam dan kegagalan deteksi IMAP
Proyek API IMAP: Banyak proyek sumber terbuka ada khusus untuk "mengubah IMAP menjadi REST" karena tidak ada penyedia yang menawarkan ini
Frustrasi API Gmail: Stack Overflow memiliki 4.847 pertanyaan berlabel "gmail-api" dengan keluhan umum tentang batas kecepatan dan kompleksitas

Solusi Revolusioner Forward Email

Kami adalah layanan email pertama yang menawarkan operasi CRUD lengkap untuk semua data email melalui API REST terpadu.

Ini bukan sekadar API pengiriman. Ini adalah kontrol programatik lengkap atas:

Pesan: Buat, baca, perbarui, hapus, cari, pindah, beri tanda
Folder: Manajemen folder IMAP penuh melalui endpoint REST
Kontak: Penyimpanan dan sinkronisasi kontak CardDAV
Kalender: Acara kalender dan penjadwalan CalDAV

Mengapa Kami Membuat Ini

Masalahnya: Setiap penyedia email memperlakukan email sebagai kotak hitam. Anda bisa mengirim email, mungkin membacanya dengan OAuth yang kompleks, tapi Anda tidak benar-benar bisa mengelola data email Anda secara programatik.

Visi Kami: Email harus semudah mengintegrasikan API modern mana pun. Tanpa pustaka IMAP. Tanpa kompleksitas OAuth. Tanpa mimpi buruk batas kecepatan. Hanya endpoint REST sederhana yang bekerja.

Hasilnya: Layanan email pertama di mana Anda bisa membangun klien email lengkap, integrasi CRM, atau sistem otomatisasi hanya dengan permintaan HTTP.

Autentikasi Sederhana

Tanpa kompleksitas OAuth. Tanpa kata sandi khusus aplikasi. Cukup kredensial alias Anda:

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

20 Endpoint yang Mengubah Segalanya

Pesan (5 endpoint)

GET /v1/messages - Daftar pesan dengan penyaringan (?folder=, ?is_unread=, ?is_flagged=)
POST /v1/messages - Kirim pesan baru langsung ke folder
GET /v1/messages/:id - Ambil pesan spesifik dengan metadata lengkap
PUT /v1/messages/:id - Perbarui pesan (flag, folder, status baca)
DELETE /v1/messages/:id - Hapus pesan secara permanen

Folder (5 endpoint)

GET /v1/folders - Daftar semua folder dengan status langganan
POST /v1/folders - Buat folder baru dengan properti kustom
GET /v1/folders/:id - Dapatkan detail folder dan jumlah pesan
PUT /v1/folders/:id - Perbarui properti folder dan langganan
DELETE /v1/folders/:id - Hapus folder dan tangani relokasi pesan

Kontak (5 endpoint)

GET /v1/contacts - Daftar kontak dengan pencarian dan paginasi
POST /v1/contacts - Buat kontak baru dengan dukungan vCard lengkap
GET /v1/contacts/:id - Ambil kontak dengan semua bidang dan metadata
PUT /v1/contacts/:id - Perbarui informasi kontak dengan validasi ETag
DELETE /v1/contacts/:id - Hapus kontak dengan penanganan cascade

Kalender (5 endpoint)

GET /v1/calendars - Daftar acara kalender dengan penyaringan tanggal
POST /v1/calendars - Buat acara kalender dengan peserta dan pengulangan
GET /v1/calendars/:id - Dapatkan detail acara dengan penanganan zona waktu
PUT /v1/calendars/:id - Perbarui acara dengan deteksi konflik
DELETE /v1/calendars/:id - Hapus acara dengan notifikasi peserta

Pencarian Lanjutan: Tidak Ada Layanan Lain yang Menyamai

Forward Email adalah satu-satunya layanan email yang menawarkan pencarian programatik komprehensif di semua bidang pesan melalui REST API.

Sementara penyedia lain hanya menawarkan penyaringan dasar, kami telah membangun API pencarian email paling canggih yang pernah dibuat. Tidak ada Gmail API, Outlook API, atau layanan lain yang mendekati kemampuan pencarian kami.

Lanskap API Pencarian yang Rusak

Batasan Pencarian Gmail API:

✅ Parameter q dasar saja
❌ Tidak ada pencarian spesifik bidang
❌ Tidak ada penyaringan rentang tanggal
❌ Tidak ada penyaringan berdasarkan ukuran
❌ Tidak ada penyaringan lampiran
❌ Terbatas pada sintaks pencarian Gmail

Batasan Pencarian Outlook API:

✅ Parameter $search dasar
❌ Tidak ada penargetan bidang lanjutan
❌ Tidak ada kombinasi kueri kompleks
❌ Pembatasan tingkat yang agresif
❌ Sintaks OData yang kompleks diperlukan

Apple iCloud:

❌ Tidak ada API sama sekali
❌ Hanya pencarian IMAP (jika bisa dijalankan)

ProtonMail & Tuta:

❌ Tidak ada API publik
❌ Tidak ada kemampuan pencarian programatik

API Pencarian Revolusioner Forward Email

Kami menawarkan 15+ parameter pencarian yang tidak disediakan layanan lain:

Kemampuan Pencarian	Forward Email	Gmail API	Outlook API	Lainnya
Pencarian Spesifik Bidang	✅ Subjek, isi, dari, ke, cc, header	❌	❌	❌
Pencarian Umum Multi-Bidang	✅ `?search=` di semua bidang	✅ Dasar `q=`	✅ Dasar `$search=`	❌
Penyaringan Rentang Tanggal	✅ `?since=` & `?before=`	❌	❌	❌
Penyaringan Berdasarkan Ukuran	✅ `?min_size=` & `?max_size=`	❌	❌	❌
Penyaringan Lampiran	✅ `?has_attachments=true/false`	❌	❌	❌
Pencarian Header	✅ `?headers=X-Priority`	❌	❌	❌
Pencarian ID Pesan	✅ `?message_id=abc123`	❌	❌	❌
Filter Gabungan	✅ Beberapa parameter dengan logika AND	❌	❌	❌
Tidak Sensitif Huruf Besar/Kecil	✅ Semua pencarian	✅	✅	❌
Dukungan Paginasi	✅ Berfungsi dengan semua parameter pencarian	✅	✅	❌

Contoh Pencarian Dunia Nyata

Temukan Semua Faktur dari Kuartal Terakhir:

# Forward Email - Sederhana dan kuat
GET /v1/messages?subject=invoice&since=2024-01-01T00:00:00Z&before=2024-04-01T00:00:00Z

# Gmail API - Tidak mungkin dengan pencarian terbatas mereka
# Tidak ada penyaringan rentang tanggal yang tersedia

# Outlook API - Sintaks OData yang kompleks, fungsi terbatas
GET /me/messages?$search="invoice"&$filter=receivedDateTime ge 2024-01-01T00:00:00Z

Cari Lampiran Besar dari Pengirim Tertentu:

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

# Gmail API - Tidak dapat memfilter berdasarkan ukuran atau lampiran secara programatik
# Outlook API - Tidak ada penyaringan ukuran yang tersedia
# Lainnya - Tidak ada API yang tersedia

Pencarian Multi-Field Kompleks:

# Forward Email - Kemampuan kueri lanjutan
GET /v1/messages?body=quarterly&from=manager&is_flagged=true&folder=Reports

# Gmail API - Terbatas pada pencarian teks dasar saja
GET /gmail/v1/users/me/messages?q=quarterly

# Outlook API - Pencarian dasar tanpa penargetan bidang
GET /me/messages?$search="quarterly"

Keunggulan Performa

Performa Pencarian Forward Email:

⚡ Waktu respons di bawah 100ms untuk pencarian kompleks
🔍 Optimasi regex dengan pengindeksan yang tepat
📊 Eksekusi kueri paralel untuk hitung dan data
💾 Penggunaan memori efisien dengan kueri ringan

Masalah Performa Pesaing:

🐌 Gmail API: Terbatas kuota 250 unit per pengguna per detik
🐌 Outlook API: Pembatasan agresif dengan persyaratan backoff kompleks
🐌 Lainnya: Tidak ada API untuk dibandingkan

Fitur Pencarian yang Tidak Dimiliki Orang Lain

1. Pencarian Spesifik Header

# Temukan pesan dengan header tertentu
GET /v1/messages?headers=X-Priority:1
GET /v1/messages?headers=X-Spam-Score

2. Intelijen Berdasarkan Ukuran

# Temukan email newsletter (biasanya besar)
GET /v1/messages?min_size=50000&from=newsletter

# Temukan balasan cepat (biasanya kecil)
GET /v1/messages?max_size=1000&to=support

3. Alur Kerja Berbasis Lampiran

# Temukan semua dokumen yang dikirim ke tim hukum
GET /v1/messages?to=legal&has_attachments=true&body=contract

# Temukan email tanpa lampiran untuk pembersihan
GET /v1/messages?has_attachments=false&before=2023-01-01T00:00:00Z

4. Logika Bisnis Gabungan

# Temukan pesan penting yang ditandai dari VIP dengan lampiran
GET /v1/messages?is_flagged=true&from=ceo&has_attachments=true&subject=urgent

Mengapa Ini Penting untuk Pengembang

Bangun Aplikasi yang Sebelumnya Tidak Mungkin:

Analitik Email Lanjutan: Analisis pola email berdasarkan ukuran, pengirim, konten
Manajemen Email Cerdas: Otomatis mengatur berdasarkan kriteria kompleks
Kepatuhan dan Penemuan: Temukan email spesifik untuk kebutuhan hukum
Intelijen Bisnis: Ekstrak wawasan dari pola komunikasi email
Alur Kerja Otomatis: Memicu tindakan berdasarkan filter email yang canggih

Implementasi Teknis

API pencarian kami menggunakan:

Optimasi regex dengan strategi pengindeksan yang tepat
Eksekusi paralel untuk performa
Validasi input untuk keamanan
Penanganan kesalahan komprehensif untuk keandalan

// Contoh: Implementasi pencarian kompleks
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' } }
    ]
  });
}

// Gabungkan dengan logika AND
if (searchConditions.length > 0) {
  query.$and = searchConditions;
}

Tip

Keuntungan Pengembang: Dengan API pencarian Forward Email, Anda dapat membangun aplikasi email yang menyaingi klien desktop dalam fungsionalitas sambil mempertahankan kesederhanaan REST API.

Arsitektur Performa Super Cepat

Tumpukan teknis kami dibangun untuk kecepatan dan keandalan:

Tolok Ukur Performa

Mengapa Kami Sangat Cepat:

Komponen	Teknologi	Manfaat Performa
Penyimpanan	NVMe SSD	10x lebih cepat daripada SATA tradisional
Database	SQLite + msgpackr	Nol latensi jaringan, serialisasi yang dioptimalkan
Perangkat Keras	AMD Ryzen bare metal	Tanpa overhead virtualisasi
Caching	Dalam memori + persisten	Waktu respons sub-milidetik
Cadangan	Cloudflare R2 terenkripsi	Keandalan tingkat perusahaan

Angka Performa Nyata:

Waktu Respons API: < 50ms rata-rata
Pengambilan Pesan: < 10ms untuk pesan yang di-cache
Operasi Folder: < 5ms untuk operasi metadata
Sinkronisasi Kontak: 1000+ kontak/detik
Waktu Aktif: SLA 99,99% dengan infrastruktur redundan

Arsitektur Berorientasi Privasi

Desain Zero-Knowledge: Hanya Anda yang memiliki akses dengan kata sandi IMAP Anda - kami tidak dapat membaca email Anda. Arsitektur zero-knowledge kami memastikan privasi lengkap sambil memberikan performa super cepat.

Mengapa Kami Berbeda: Perbandingan Lengkap

Keterbatasan Penyedia Utama

Penyedia	Masalah Utama	Keterbatasan Spesifik
Gmail API	Hanya baca, OAuth kompleks, API terpisah	• Tidak dapat memodifikasi pesan yang ada • Label ≠ folder • Batas kuota 1 miliar unit/hari • Memerlukan API terpisah untuk kontak/kalender
Outlook API	Tidak lagi didukung, membingungkan, fokus perusahaan	• REST endpoint dihentikan Maret 2024 • Banyak API membingungkan (EWS, Graph, REST) • Kompleksitas Microsoft Graph • Pembatasan agresif
Apple iCloud	Tidak ada API Publik	• Tidak ada API publik sama sekali • Hanya IMAP dengan batas 1000 email/hari • Diperlukan kata sandi khusus aplikasi • Batas 500 penerima per pesan
ProtonMail	Tidak ada API, Klaim Open-Source Palsu	• Tidak ada API publik tersedia • Perlu perangkat lunak Bridge untuk akses IMAP • Mengklaim "open source" tetapi kode server adalah proprietary • Terbatas hanya untuk paket berbayar
Tuta	Tidak ada API, Transparansi Menyesatkan	• Tidak ada REST API untuk manajemen email • Mengklaim "open source" tetapi backend tertutup • IMAP/SMTP tidak didukung • Enkripsi proprietary mencegah integrasi standar
Zapier Email	Batasan Tingkat Parah	• Batas 10 email per jam • Tidak ada akses folder IMAP • Kemampuan parsing terbatas

Keuntungan Meneruskan Email

Fitur	Meneruskan Email	Kompetisi
CRUD Lengkap	✅ Buat, baca, perbarui, hapus penuh untuk semua data	❌ Hanya baca atau operasi terbatas
API Terpadu	✅ Pesan, folder, kontak, kalender dalam satu API	❌ API terpisah atau fitur hilang
Otentikasi Sederhana	✅ Otentikasi dasar dengan kredensial alias	❌ OAuth kompleks dengan banyak cakupan
Tanpa Batasan Kecepatan	✅ Batasan dermawan yang dirancang untuk aplikasi nyata	❌ Kuota ketat yang mengganggu alur kerja
Self-Hosting	✅ Opsi self-hosting lengkap	❌ Hanya terkunci pada vendor
Privasi	✅ Zero-knowledge, terenkripsi, pribadi	❌ Penambangan data dan masalah privasi
Performa	✅ Respon sub-50ms, penyimpanan NVMe	❌ Latensi jaringan, penundaan throttling

Masalah Transparansi Open-Source

ProtonMail dan Tuta memasarkan diri mereka sebagai "open source" dan "transparan," tetapi ini adalah pemasaran menyesatkan yang melanggar prinsip privasi modern.

Warning

Klaim Transparansi Palsu: Baik ProtonMail maupun Tuta secara mencolok mengiklankan kredensial "open source" mereka sementara kode server paling kritis tetap bersifat proprietary dan tertutup.

Penipuan ProtonMail:

Klaim: "Kami open source" yang ditampilkan secara mencolok dalam pemasaran
Realita: Kode server sepenuhnya proprietary - hanya aplikasi klien yang open source
Dampak: Pengguna tidak dapat memverifikasi enkripsi sisi server, penanganan data, atau klaim privasi
Pelanggaran Transparansi: Tidak ada cara untuk mengaudit sistem pemrosesan dan penyimpanan email yang sebenarnya

Pemasaran Menyesatkan Tuta:

Klaim: "Email open source" sebagai poin penjualan utama
Realita: Infrastruktur backend tertutup - hanya frontend yang tersedia
Dampak: Enkripsi proprietary mencegah protokol email standar (IMAP/SMTP)
Strategi Lock-in: Enkripsi khusus memaksa ketergantungan pada vendor

Mengapa Ini Penting untuk Privasi Modern:

Di tahun 2025, privasi sejati membutuhkan transparansi lengkap. Ketika penyedia email mengklaim "open source" tetapi menyembunyikan kode server mereka:

Enkripsi Tidak Terverifikasi: Anda tidak dapat mengaudit bagaimana data Anda sebenarnya dienkripsi
Praktik Data Tersembunyi: Penanganan data sisi server tetap menjadi kotak hitam
Keamanan Berbasis Kepercayaan: Anda harus mempercayai klaim mereka tanpa verifikasi
Lock-in Vendor: Sistem proprietary mencegah portabilitas data

Transparansi Sejati Forward Email:

✅ Open source lengkap - kode server dan klien
✅ Self-hosting tersedia - jalankan instance Anda sendiri
✅ Protokol standar - kompatibilitas IMAP, SMTP, CardDAV, CalDAV
✅ Keamanan dapat diaudit - setiap baris kode dapat diperiksa
✅ Tanpa lock-in vendor - data Anda, kontrol Anda

Tip

Open source sejati berarti Anda dapat memverifikasi setiap klaim. Dengan Forward Email, Anda dapat mengaudit enkripsi kami, meninjau penanganan data kami, dan bahkan menjalankan instance Anda sendiri. Itulah transparansi sejati.

30+ Contoh Integrasi Dunia Nyata

1. Peningkatan Form Kontak WordPress

Masalah: Kegagalan konfigurasi SMTP WordPress (631 isu GitHub)
Solusi: Integrasi API langsung melewati SMTP sepenuhnya

// Form kontak WordPress yang menyimpan ke folder Terkirim
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: 'Form Kontak: ' + formData.subject,
    text: formData.message,
    folder: 'Sent'
  })
});

2. Alternatif Zapier untuk Otomasi Email

Masalah: Batas 10 email/jam Zapier dan kegagalan deteksi IMAP
Solusi: Otomasi tanpa batas dengan kontrol email penuh

// Mengatur email secara otomatis berdasarkan domain pengirim
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. Sinkronisasi Email CRM

Masalah: Manajemen kontak manual antara email dan sistem CRM
Solusi: Sinkronisasi dua arah dengan API kontak CardDAV

// Sinkronisasi kontak email baru ke 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. Pemrosesan Pesanan E-commerce

Masalah: Pemrosesan email pesanan manual untuk platform e-commerce
Solusi: Pipeline manajemen pesanan otomatis

// Memproses email konfirmasi pesanan
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. Integrasi Tiket Dukungan

Masalah: Thread email tersebar di berbagai platform helpdesk
Solusi: Pelacakan thread email lengkap

// Membuat tiket dukungan dari thread email
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
  });
}

Masalah: Integrasi terbatas dengan platform newsletter
Solusi: Manajemen siklus hidup pelanggan lengkap

// Mengelola langganan newsletter secara otomatis
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. Manajemen Tugas Berbasis Email

Masalah: Kotak masuk penuh dan pelacakan tugas
Solusi: Mengubah email menjadi tugas yang dapat ditindaklanjuti

// 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. Cadangan Email dan Kepatuhan

Masalah: Retensi email dan persyaratan kepatuhan
Solusi: Cadangan otomatis dengan pelestarian 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. Manajemen Konten Berbasis Email

Masalah: Mengelola pengiriman konten melalui email untuk platform CMS
Solusi: Email sebagai sistem manajemen konten

// 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. Manajemen Template Email

Masalah: Template email yang tidak konsisten di seluruh tim
Solusi: Sistem template terpusat dengan 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. Otomatisasi Alur Kerja Berbasis Email

Masalah: Proses persetujuan manual melalui email
Solusi: Pemicu alur kerja otomatis

// 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. Pemantauan Keamanan Email

Masalah: Deteksi ancaman keamanan manual
Solusi: Analisis ancaman otomatis

// 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. Pengumpulan Survei Berbasis Email

Masalah: Pemrosesan respon survei manual
Solusi: Agregasi respon otomatis

// 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. Pemantauan Kinerja Email

Masalah: Tidak ada visibilitas ke dalam kinerja pengiriman email
Solusi: Metrik email waktu nyata

// 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. Kualifikasi Lead Berbasis Email

Masalah: Penilaian lead manual dari interaksi email
Solusi: Pipeline kualifikasi lead otomatis

// Skor lead berdasarkan keterlibatan email
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. Manajemen Proyek Berbasis Email

Masalah: Pembaruan proyek tersebar di berbagai thread email
Solusi: Pusat komunikasi proyek terpusat

// Ekstrak pembaruan proyek dari email
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. Manajemen Inventaris Berbasis Email

Masalah: Pembaruan inventaris manual dari email pemasok
Solusi: Pelacakan inventaris otomatis dari notifikasi email

// Proses pembaruan inventaris dari email pemasok
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
  });

  // Pindahkan ke folder yang sudah diproses
  await fetch(`/v1/messages/${email.id}`, {
    method: 'PUT',
    body: JSON.stringify({ folder: 'Suppliers/Processed' })
  });
}

22. Pemrosesan Faktur Berbasis Email

Masalah: Pemrosesan faktur manual dan integrasi akuntansi
Solusi: Ekstraksi faktur otomatis dan sinkronisasi sistem akuntansi

// Ekstrak data faktur dari lampiran email
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
  });

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

23. Pendaftaran Acara Berbasis Email

Masalah: Pemrosesan pendaftaran acara manual dari balasan email
Solusi: Manajemen peserta otomatis dan integrasi kalender

// Proses email pendaftaran acara
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);

  // Tambahkan ke daftar peserta
  await events.addAttendee({
    event: attendeeData.eventId,
    name: attendeeData.name,
    email: registration.from,
    dietary: attendeeData.dietaryRestrictions
  });

  // Buat acara kalender untuk peserta
  await fetch('/v1/calendars', {
    method: 'POST',
    body: JSON.stringify({
      title: attendeeData.eventName,
      start: attendeeData.eventDate,
      attendees: [registration.from]
    })
  });
}

24. Alur Kerja Persetujuan Dokumen Berbasis Email

Masalah: Rantai persetujuan dokumen yang kompleks melalui email
Solusi: Pelacakan persetujuan otomatis dan versi dokumen

// 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. Analisis Umpan Balik Pelanggan Berbasis Email

Masalah: Pengumpulan dan analisis sentimen umpan balik pelanggan secara manual
Solusi: Pemrosesan umpan balik otomatis dan pelacakan sentimen

// 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. Pipeline Rekrutmen Berbasis Email

Masalah: Pelacakan rekrutmen dan kandidat secara manual
Solusi: Manajemen kandidat otomatis dan penjadwalan wawancara

// 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. Pemrosesan Laporan Pengeluaran Berbasis Email

Masalah: Pengajuan dan persetujuan laporan pengeluaran secara manual
Solusi: Ekstraksi pengeluaran otomatis dan alur kerja persetujuan

// 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. Pelaporan Jaminan Kualitas Berbasis Email

Masalah: Pelacakan masalah jaminan kualitas secara manual
Solusi: Manajemen masalah QA dan pelacakan bug otomatis

// 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. Manajemen Vendor Berbasis Email

Masalah: Komunikasi vendor dan pelacakan kontrak secara manual
Solusi: Manajemen hubungan vendor otomatis

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

Masalah: Pelacakan dan tanggapan media sosial secara manual
Solusi: Pemrosesan peringatan media sosial otomatis dan koordinasi tanggapan

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

Memulai

1. Buat Akun Email Forward Anda

Daftar di forwardemail.net dan verifikasi domain Anda.

2. Hasilkan Kredensial API

Email alias dan kata sandi Anda berfungsi sebagai kredensial API - tidak diperlukan pengaturan tambahan.

3. Buat Panggilan API Pertama Anda

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

# Buat kontak baru
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. Jelajahi Dokumentasi

Kunjungi forwardemail.net/en/email-api untuk dokumentasi API lengkap dengan contoh interaktif.

Sumber Daya Teknis

Dokumentasi API Lengkap - Spesifikasi OpenAPI 3.0 interaktif
Panduan Self-Hosting - Deploy Forward Email di infrastruktur Anda
Whitepaper Keamanan - Arsitektur teknis dan detail keamanan
Repositori GitHub - Kode sumber terbuka
Dukungan Pengembang - Akses langsung ke tim engineering kami

Siap merevolusi integrasi email Anda? Mulai membangun dengan API Forward Email hari ini dan rasakan platform manajemen email lengkap pertama yang dirancang untuk pengembang.

Forward Email: Layanan email yang akhirnya memahami API dengan benar.