API Email Lengkap Pertama: Bagaimana Forward Email Merevolusi Manajemen Email

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 menggunakan 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. Inilah API email yang telah lama ditunggu-tunggu oleh para pengembang.

Masalah API Email

API email pada dasarnya rusak. Titik.

Setiap penyedia email utama memaksa pengembang untuk membuat salah satu dari dua pilihan buruk:

  1. IMAP Hell: Bergulat dengan protokol berusia 30 tahun yang dirancang untuk klien desktop, bukan aplikasi modern
  2. API yang Lumpuh: API yang kompleks dengan batasan kecepatan, hanya baca, dan OAuth yang tidak dapat mengelola data email Anda yang sebenarnya

Hasilnya? Para pengembang akhirnya mengabaikan integrasi email sepenuhnya atau membuang waktu berminggu-minggu untuk membangun pembungkus IMAP yang rapuh dan terus-menerus rusak.

Warning

Rahasia Rahasia: Kebanyakan "API email" hanyalah API pengiriman. Anda tidak dapat mengatur folder, menyinkronkan kontak, atau mengelola kalender secara terprogram melalui antarmuka REST yang sederhana. Hingga saat ini.

Apa yang Sebenarnya Dikatakan Pengembang

Frustrasi itu nyata dan terdokumentasi di mana-mana:

"Baru-baru ini saya mencoba mengintegrasikan Gmail ke dalam aplikasi saya, dan saya menghabiskan terlalu banyak waktu untuk itu. Saya memutuskan bahwa tidak ada gunanya mendukung Gmail."

- Pengembang Hacker News, 147 suara positif

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

- Diskusi Reddit r/SaaS

"Mengapa pengembangan email harus buruk?"

- Reddit r/webdev, 89 komentar tentang kesulitan pengembang

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

- Pertanyaan Stack Overflow dengan 47 upvote

Buktinya ada dimana-mana:

  • Masalah SMTP WordPress: 631 masalah GitHub tentang kegagalan pengiriman email
  • Keterbatasan Zapier: Keluhan masyarakat tentang batas 10 email/jam dan kegagalan deteksi IMAP
  • Proyek API IMAP: Banyak sumber terbuka proyek dibuat khusus untuk "mengonversi IMAP ke REST" karena tidak ada penyedia yang menawarkan ini
  • Kekecewaan API Gmail: Tumpukan Luapan memiliki 4.847 pertanyaan yang ditandai "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 REST API terpadu.

Ini bukan sekadar API pengiriman biasa. Ini adalah kendali terprogram penuh atas:

  • Pesan: Membuat, membaca, memperbarui, menghapus, mencari, memindahkan, menandai
  • Folder: Manajemen folder IMAP penuh melalui titik akhir REST
  • Kontak: Penyimpanan dan sinkronisasi kontak KartuDAV
  • Kalender: Acara dan penjadwalan kalender CalDAV

Mengapa Kami Membangun Ini

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

Visi Kami: Email harus semudah integrasi API modern mana pun. Tanpa pustaka IMAP. Tanpa kerumitan OAuth. Tanpa mimpi buruk batas kecepatan. Hanya titik akhir REST sederhana yang berfungsi.

Hasilnya: Layanan email pertama tempat Anda dapat membangun klien email lengkap, integrasi CRM, atau sistem otomasi hanya dengan menggunakan permintaan HTTP.

Autentikasi Sederhana

Tidak ada Kompleksitas OAuth. Tidak ada kata sandi khusus aplikasi. Hanya kredensial alias Anda:

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

20 Titik Akhir yang Mengubah Segalanya

Pesan (5 titik akhir)

  • GET /v1/messages - Daftar pesan dengan pemfilteran (?folder=, ?is_unread=, ?is_flagged=)
  • POST /v1/messages - Kirim pesan baru langsung ke folder
  • GET /v1/messages/:id - Ambil pesan tertentu dengan metadata lengkap
  • PUT /v1/messages/:id - Perbarui pesan (tanda, folder, status telah dibaca)
  • DELETE /v1/messages/:id - Hapus pesan secara permanen

Folder (5 titik akhir)

  • GET /v1/folders - Daftar semua folder dengan status langganan
  • POST /v1/folders - Buat folder baru dengan properti khusus
  • 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 titik akhir)

  • GET /v1/contacts - Daftar kontak dengan pencarian dan paginasi
  • POST /v1/contacts - Buat kontak baru dengan dukungan vCard penuh
  • GET /v1/contacts/:id - Ambil kontak beserta semua kolom dan metadata
  • PUT /v1/contacts/:id - Perbarui informasi kontak dengan validasi ETag
  • DELETE /v1/contacts/:id - Hapus kontak dengan penanganan berjenjang

Kalender (5 titik akhir)

  • GET /v1/calendars - Daftar acara kalender dengan pemfilteran 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 Membandingkan

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

Meskipun penyedia lain hanya menawarkan penyaringan dasar, kami telah membangun API pencarian email tercanggih yang pernah ada. Tidak ada API Gmail, API Outlook, atau layanan lain yang mampu menandingi kemampuan pencarian kami.

Lanskap API Penelusuran Rusak

Keterbatasan Pencarian API Gmail:

  • ✅ Hanya parameter dasar q
  • ❌ Tidak ada pencarian khusus bidang
  • ❌ Tidak ada pemfilteran rentang tanggal
  • ❌ Tidak ada pemfilteran berdasarkan ukuran
  • ❌ Tidak ada pemfilteran lampiran
  • ❌ Terbatas pada sintaks pencarian Gmail

Keterbatasan Pencarian API Outlook:

  • ✅ Parameter $search dasar
  • ❌ Tidak ada penargetan kolom lanjutan
  • ❌ Tidak ada kombinasi kueri yang kompleks
  • ❌ Pembatasan laju yang agresif
  • ❌ Diperlukan sintaks OData yang kompleks

Apple iCloud:

  • ❌ Tanpa API sama sekali
  • ❌ Hanya pencarian IMAP (jika Anda bisa membuatnya berfungsi)

ProtonMail & Tuta:

  • ❌ Tidak ada API publik
  • ❌ Tidak ada kemampuan pencarian terprogram

API Pencarian Revolusioner Forward Email

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

Kemampuan Pencarian Teruskan Email Gmail API API Outlook Yang lain
Pencarian Khusus Bidang ✅ Subjek, isi, dari, kepada, cc, tajuk ❌ ❌ ❌
Pencarian Umum Multi-Bidang ✅ ?search= di semua bidang ✅ Dasar q= ✅ Dasar $search= ❌
Pemfilteran Rentang Tanggal ✅ ?since= & ?before= ❌ ❌ ❌
Penyaringan Berbasis Ukuran ✅ ?min_size= & ?max_size= ❌ ❌ ❌
Pemfilteran Lampiran ✅ ?has_attachments=true/false ❌ ❌ ❌
Pencarian Header ✅ ?headers=X-Priority ❌ ❌ ❌
Pencarian ID Pesan ✅ ?message_id=abc123 ❌ ❌ ❌
Filter Gabungan ✅ Beberapa parameter dengan logika AND ❌ ❌ ❌
Tidak Peka terhadap Huruf Besar/Kecil ✅ Semua pencarian ✅ ✅ ❌
Dukungan Paginasi ✅ Bekerja dengan semua parameter pencarian ✅ ✅ ❌

Contoh Pencarian Dunia Nyata

Temukan Semua Faktur dari Kuartal Terakhir:

# 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

Cari Lampiran Besar dari Pengirim Tertentu:

# 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

Pencarian Multi-Bidang Kompleks:

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

Keunggulan Performa

Kinerja Pencarian Email Teruskan:

  • ⚡ Waktu respons di bawah 100 ms untuk pencarian kompleks
  • 🔍 Optimasi Regex dengan pengindeksan yang tepat
  • 📊 Eksekusi kueri paralel untuk hitungan dan data
  • 💾 Penggunaan memori yang efisien dengan kueri yang ramping

Masalah Kinerja Pesaing:

  • 🐌 API Gmail: Batas kuota hingga 250 unit kuota per pengguna per detik
  • 🐌 API Outlook: Pembatasan agresif dengan persyaratan penundaan yang kompleks
  • 🐌 Lainnya: Tidak ada API yang dapat dibandingkan

Fitur Pencarian yang Tidak Dimiliki Orang Lain

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

2. Kecerdasan Berbasis Ukuran

# 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. Alur Kerja Berbasis Lampiran

# 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. Logika Bisnis Gabungan

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

Mengapa Hal Ini Penting bagi Pengembang

Membangun Aplikasi yang Sebelumnya Tidak Mungkin:

  1. Analisis Email Lanjutan: Analisis pola email berdasarkan ukuran, pengirim, dan konten
  2. Manajemen Email Cerdas: Atur otomatis berdasarkan kriteria yang kompleks
  3. Kepatuhan dan Penemuan: Temukan email spesifik untuk persyaratan hukum
  4. Kecerdasan Bisnis: Ekstrak wawasan dari pola komunikasi email
  5. Alur Kerja Otomatis: Picu tindakan berdasarkan filter email yang canggih

Implementasi Teknis

API pencarian kami menggunakan:

Optimalisasi Regex dengan strategi pengindeksan yang tepat

  • Eksekusi paralel untuk performa
  • Validasi input untuk keamanan
  • Penanganan kesalahan komprehensif untuk keandalan
// 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

Keunggulan Pengembang: Dengan API pencarian Forward Email, Anda dapat membangun aplikasi email yang fungsionalitasnya menyaingi klien desktop, sekaligus tetap mempertahankan kesederhanaan REST API.

Arsitektur Performa Super Cepat

Tumpukan teknis kami dibuat untuk kecepatan dan keandalan:

Tolok Ukur Kinerja

Mengapa Kami Sangat Cepat:

Komponen Teknologi Manfaat Kinerja
Penyimpanan NVMe SSD 10x lebih cepat dari SATA tradisional
Basis Data SQLite + msgpackr Latensi jaringan nol, serialisasi yang dioptimalkan
Perangkat keras AMD Ryzen logam polos Tidak ada overhead virtualisasi
Penyimpanan dalam cache Dalam memori + persisten Waktu respons sub-milidetik
Cadangan Cloudflare R2 terenkripsi Keandalan tingkat perusahaan

Angka Kinerja Nyata:

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

Arsitektur Privasi Utama

Desain Tanpa Pengetahuan: Hanya Anda yang memiliki akses dengan kata sandi IMAP Anda - kami tidak dapat membaca email Anda. arsitektur tanpa pengetahuan kami memastikan privasi penuh sekaligus memberikan kinerja yang luar biasa.

Mengapa Kami Berbeda: Perbandingan Lengkap

Batasan Penyedia Utama

Penyedia Masalah Inti Batasan Khusus
Gmail API Hanya baca, OAuth Kompleks, API Terpisah • Cannot modify existing messages
• Labels ≠ folders
• 1 billion quota units/day limit
• Requires separate APIs untuk kontak/kalender
API Outlook Tidak digunakan lagi, Membingungkan, Berfokus pada Perusahaan • REST endpoints deprecated March 2024
• Multiple confusing APIs (EWS, Grafik, REST)
• Microsoft Graph complexity
• Aggressive throttling
Apple iCloud Tidak Ada API Publik • No public API whatsoever
• IMAP-only with 1000 emails/day limit
• App-specific passwords required
• 500 recipients per message limit
ProtonMail Tidak Ada API, Klaim Open-Source Palsu • No public API available
• Bridge software required untuk akses IMAP
• Claims "open source" tetapi server code is proprietary
• Limited to paid plans only
Total Tidak Ada API, Transparansi Menyesatkan • No REST API for email management
• Claims "open source" tetapi backend is closed
• IMAP/SMTP not supported
• Proprietary encryption mencegah integrasi standar
Email Zapier Batasan Tarif Parah • 10 emails per hour limit
• No IMAP folder access
• Limited parsing capabilities

Keuntungan Meneruskan Email

Fitur Teruskan Email Kompetisi
CRUD Lengkap ✅ Buat, baca, perbarui, hapus penuh untuk semua data ❌ Operasi hanya baca atau terbatas
API Terpadu ✅ Pesan, folder, kontak, kalender dalam satu API ❌ API terpisah atau fitur yang hilang
Otorisasi Sederhana ✅ Otentikasi dasar dengan kredensial alias ❌ OAuth kompleks dengan beberapa cakupan
Tidak Ada Batasan Tarif ✅ Batasan yang besar dirancang untuk aplikasi nyata ❌ Kuota terbatas yang mengganggu alur kerja
Hosting Mandiri ✅ Complete self-hosting option ❌ Hanya untuk vendor lock-in
Pribadi ✅ Tanpa pengetahuan, terenkripsi, pribadi ❌ Penambangan data dan masalah privasi
Pertunjukan ✅ Respons di bawah 50 ms, penyimpanan NVMe ❌ Latensi jaringan, penundaan pelambatan

Masalah Transparansi Sumber Terbuka

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

Warning

Klaim Transparansi Palsu: Baik ProtonMail maupun Tuta secara terang-terangan mengiklankan kredensial "sumber terbuka" mereka, namun tetap menjaga kode sisi server mereka yang paling penting tetap bersifat privat dan tertutup.

Penipuan ProtonMail:

  • Klaim: "Kami adalah sumber terbuka" ditampilkan secara mencolok dalam pemasaran
  • Realitas: Kode server sepenuhnya merupakan hak milik - hanya aplikasi klien yang bersifat sumber terbuka
  • 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 Tuta yang Menyesatkan:

Mengapa Hal Ini Penting untuk Privasi Modern:

Pada tahun 2025, privasi sejati membutuhkan transparansi penuh. Ketika penyedia email mengklaim "sumber terbuka" tetapi menyembunyikan kode server mereka:

  1. Enkripsi yang Tidak Dapat Diverifikasi: Anda tidak dapat mengaudit bagaimana data Anda sebenarnya dienkripsi
  2. Praktik Data Tersembunyi: Penanganan data sisi server tetap menjadi kotak hitam
  3. Keamanan Berbasis Kepercayaan: Anda harus memercayai klaim mereka tanpa verifikasi
  4. Penguncian Vendor: Sistem kepemilikan mencegah portabilitas data

Transparansi Sejati Email Teruskan:

  • ✅ Sumber terbuka lengkap - kode server dan klien
  • ✅ Hosting mandiri tersedia - jalankan instans Anda sendiri
  • ✅ Protokol standar - kompatibilitas IMAP, SMTP, CardDAV, CalDAV
  • ✅ Keamanan yang dapat diaudit - setiap baris kode dapat diperiksa
  • ✅ Tanpa vendor lock-in - data Anda, kendali Anda

Tip

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

30+ Contoh Integrasi Dunia Nyata

1. Peningkatan Formulir Kontak WordPress

Masalah: Kegagalan konfigurasi SMTP WordPress (631 masalah GitHub) Solusi: Integrasi API langsung mengabaikan SMTP sepenuhnya

// 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. Alternatif Zapier untuk Otomatisasi Email

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

// 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. Sinkronisasi Email CRM

Masalah: Manajemen kontak manual antara email dan Sistem CRM Solusi: Sinkronisasi dua arah dengan API kontak KartuDAV

// 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. Pemrosesan Pesanan E-niaga

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

// 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. Integrasi Tiket Dukungan

Masalah: Rangkaian email tersebar di platform meja bantuan Solusi: Pelacakan rangkaian email secara menyeluruh

// 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. Sistem Manajemen Buletin

Masalah: Integrasi platform buletin terbatas Solusi: Manajemen siklus hidup pelanggan yang lengkap

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

Masalah: Kotak masuk penuh dan pelacakan tugas Solusi: Ubah 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. Agregasi Email Multi-Akun

Masalah: Mengelola beberapa akun email di seluruh penyedia Solusi: Antarmuka kotak masuk terpadu

// 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. Dasbor Analisis Email Lanjutan

Masalah: Tidak ada wawasan tentang pola email dengan pemfilteran canggih Solusi: Analisis email khusus menggunakan kemampuan pencarian lanjutan

// 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. Pengarsipan Email Cerdas

Masalah: Manual organisasi email Solusi: Kategorisasi email yang cerdas

// 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. Integrasi Email ke Kalender

Masalah: Pembuatan acara kalender secara manual dari email Solusi: Ekstraksi dan pembuatan peristiwa secara otomatis

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

Masalah: Retensi email dan persyaratan kepatuhan Solusi: Pencadangan 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 kiriman 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: templat email tidak konsisten di seluruh tim Solusi: Sistem templat 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 tanggapan survei manual Solusi: Agregasi respons 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 kinerja pengiriman email Solusi: Metrik email real-time

// 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 Prospek Berbasis Email

Masalah: Manual skor prospek dari interaksi email Solusi: Jalur kualifikasi prospek otomatis

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

Masalah: Pembaruan proyek tersebar di seluruh rangkaian email Solusi: Pusat komunikasi proyek terpusat

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

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

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

Masalah: Integrasi manual pemrosesan faktur dan akuntansi Solusi: Ekstraksi faktur otomatis dan sinkronisasi sistem akuntansi

// 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. Pendaftaran Acara Berbasis Email

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

// 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. 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 umpan balik pelanggan manual dan analisis sentimen Solusi: Pemrosesan umpan balik dan pelacakan sentimen otomatis

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

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

// 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: Pengiriman dan persetujuan laporan pengeluaran secara manual Solusi: Alur kerja ekstraksi dan persetujuan pengeluaran otomatis

// 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 manual Solusi: Manajemen masalah QA otomatis dan pelacakan bug

// 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: Pelacakan komunikasi vendor dan kontrak 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)
    });
  }
}

30. Pemantauan Media Sosial Berbasis Email

Masalah: Pelacakan dan respons penyebutan media sosial manual Solusi: Pemrosesan notifikasi media sosial dan koordinasi respons otomatis

// 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 Penerusan 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. Lakukan Panggilan API Pertama Anda

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

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

Sumber Daya Teknis

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

Email Terusan: Layanan email yang akhirnya menggunakan API yang tepat.