MERU Inbound vs Resend: The Better Way to Handle Inbound Email

Resend has modernized the developer email API experience, but it’s primarily designed for outbound email delivery. If you need robust inbound email processing, MERU offers a purpose-built platform that eliminates complexity while providing superior developer experience.

---

Platform Philosophy Comparison

Aspect	MERU	Resend
Primary Focus	Inbound email processing	Outbound email delivery
Inbound Strategy	Core product, purpose-built	Secondary feature, basic support
Developer Experience	Inbound-optimized APIs	Outbound-optimized APIs
Data Processing	Stream-and-purge, privacy-first	Standard storage model
Address Management	Dynamic API provisioning	Static configuration

---

API Design Comparison

MERU: Inbound-First API Design

// Clean, purpose-built for inbound processing
import { Meru } from '@meru/node-sdk';

const meru = new Meru('your-api-key');

// Create unique inbound address
const address = await meru.addresses.create({
  userId: 'user_123',
  webhookUrl: 'https://your-app.com/webhook/user_123',
  ttlHours: 720,
  labels: ['support', 'priority']
});

// Process webhooks with structured data
app.post('/webhook/:userId', (req, res) => {
  const event = meru.verifyWebhook(req.body, req.headers);
  
  // Rich, structured data ready to use
  const email = {
    id: event.headers.messageId,
    subject: event.headers.subject,
    from: event.envelope.mailFrom,
    content: event.text || event.html,
    attachments: event.attachments, // Already processed
    spam: event.spam.score,
    authentication: event.authResults
  };
  
  processUserEmail(req.params.userId, email);
  res.json({ status: 'received' });
});

Resend: Outbound-First with Basic Inbound

// Resend focuses on outbound, inbound is limited
import { Resend } from 'resend';

const resend = new Resend('your-api-key');

// Outbound email (primary use case)
await resend.emails.send({
  from: 'you@example.com',
  to: 'user@example.com',
  subject: 'Hello!',
  html: '<p>Hello world!</p>'
});

// Inbound handling is basic
app.post('/resend-webhook', (req, res) => {
  // Limited inbound data structure
  const email = req.body;
  
  // Manual processing required
  const subject = email.subject;
  const content = email.text || email.html;
  
  // Handle attachments manually if supported
  // Implement your own spam filtering
  // No rich metadata provided
  
  res.json({ received: true });
});

---

Feature Comparison Matrix

Feature	MERU	Resend
Dynamic Address Creation	✅ Full API support	❌ Limited/manual setup
Webhook Verification	✅ HMAC with replay protection	✅ Basic signature verification
Structured JSON Data	✅ Rich, parsed format	⚠️ Basic format
Attachment Processing	✅ Automatic base64 decoding	❌ Manual handling required
Spam Filtering	✅ Built-in ML models	❌ DIY implementation
Authentication Results	✅ SPF, DKIM, DMARC included	❌ Not provided
Per-Address Webhooks	✅ Unique URLs per address	❌ Single webhook endpoint
TTL Management	✅ Automatic cleanup	❌ Manual management

---

Real-World Use Cases

Support Ticket System

MERU Implementation:

// Automatic ticket creation from structured data
app.post('/support/webhook/:userId', async (req, res) => {
  const event = meru.verifyWebhook(req.body, req.headers);
  
  const ticket = await supportSystem.createTicket({
    customerId: req.params.userId,
    subject: event.headers.subject,
    content: event.text,
    priority: determinePriority(event.headers.subject),
    attachments: event.attachments.map(att => ({
      filename: att.filename,
      data: att.content, // Already base64 decoded
      contentType: att.contentType
    })),
    spam: event.spam.score < 5.0 ? 'clean' : 'filtered'
  });
  
  res.json({ ticketId: ticket.id });
});

Resend Implementation:

// Much more manual processing required
app.post('/resend-support-webhook', async (req, res) => {
  const email = req.body;
  
  // Manual parsing and processing
  const priority = email.subject?.toLowerCase().includes('urgent') ? 'high' : 'normal';
  
  // No spam filtering provided
  // No attachment processing built-in
  // No authentication verification
  // No structured metadata
  
  const ticket = await supportSystem.createTicket({
    subject: email.subject,
    content: email.text || email.html,
    priority: priority
    // Missing: spam filtering, attachments, rich metadata
  });
  
  res.json({ ticketId: ticket.id });
});

Result: MERU reduces implementation complexity by 70%

---

Pricing Comparison

MERU (Inbound-Specialized)

• Starter: $10/month → 1,300 inbound emails
• Growth: $25/month → 5,000 inbound emails
• Scale: $50/month → 15,000 inbound emails
• No outbound requirements or limits

Resend (Outbound-Focused)

• Free: 100 emails/month (primarily outbound)
• Pro: $20/month → 50,000 emails/month (mixed)
• Scale: $85/month → 1M emails/month (mixed)
• Inbound features limited across all tiers

For 5,000 inbound emails/month:

• MERU: $25/month with full inbound features
• Resend: $20/month but limited inbound capabilities
• MERU provides 5x more inbound features for similar cost

---

Security & Compliance

MERU Security Model

• SOC 2 Type II aligned by design
• Stream-and-purge processing (no long-term storage)
• Per-webhook HMAC secrets
• Timestamp-based replay protection
• Zero-trust architecture for inbound processing

Resend Security Model

• Standard security practices
• Traditional storage model
• Basic webhook verification
• Shared security across outbound/inbound
• General platform security controls

---

Developer Experience

API Consistency

MERU: Every API endpoint optimized for inbound use cases

// Consistent, inbound-focused API
meru.addresses.create(options)
meru.addresses.list(filters) 
meru.addresses.update(id, changes)
meru.addresses.delete(id)
meru.webhooks.verify(body, signature)

Resend: APIs primarily designed for outbound, inbound feels secondary

// Outbound-optimized API with basic inbound support
resend.emails.send(options)      // Primary focus
resend.domains.add(domain)       // Outbound setup
resend.webhooks.verify()         // Basic inbound support

Documentation Quality

• MERU: 100% focused on inbound use cases and patterns
• Resend: Primarily outbound documentation with minimal inbound coverage

---

Migration Scenarios

From Resend to MERU

Recommended when:

• Inbound email is critical to your application
• You need advanced inbound features (spam filtering, structured data)
• You want to eliminate MIME parsing complexity
• SOC 2 compliance is required

Migration steps:

1. Set up MERU webhooks alongside existing Resend
2. Test inbound processing with MERU
3. Update DNS to route inbound emails to MERU
4. Keep Resend for outbound if needed
5. Enjoy cleaner inbound processing

---

When to Choose Each

Choose MERU if:

• Inbound email processing is core to your application
• You need advanced inbound features (spam filtering, structured data)
• Developer productivity on inbound flows is important
• SOC 2 compliance is required
• You want specialized inbound expertise and support

Choose Resend if:

• Outbound email delivery is your primary need
• You need modern outbound APIs and templates
• Basic inbound processing is sufficient
• You prefer single provider for both directions
• React email templates are valuable to you

---

The Bottom Line

Resend revolutionized outbound email APIs, making them modern and developer-friendly. However, their inbound capabilities are still basic and secondary.

MERU provides the same modern API experience, but purpose-built for inbound:

✅ Superior inbound features - spam filtering, structured data, authentication
✅ Developer productivity - no MIME parsing, rich metadata
✅ Security-first - SOC 2 aligned, stream-and-purge
✅ Specialized expertise - team focused 100% on inbound

For teams where inbound email processing is critical, MERU delivers the modern developer experience that Resend brought to outbound.

Start Free Trial • View API Docs • Compare All Features