Examples

Production-ready code examples to help you build AI agents with email capabilities.

Quick Start

The fastest way to get started with Myxara:

import { MyxaraClient } from '@myxara/sdk-js'

const client = new MyxaraClient({
  apiKey: process.env.MYXARA_API_KEY!
})

// Create inbox
const inbox = await client.inboxes.create({
  local_part: 'support',
  name: 'AI Support Agent'
})

// Send email
await client.inboxes.messages(inbox.id).send({
  to: 'customer@example.com',
  subject: 'Hello from Myxara!',
  html: '<p>Your AI agent is ready.</p>',
  text: 'Your AI agent is ready.'
})

console.log(`Inbox created: ${inbox.address}`)

Full quick start guide →

Use Cases

AI Customer Support

Build an intelligent support agent that automatically responds to customer emails:

import { MyxaraClient } from '@myxara/sdk-js'
import OpenAI from 'openai'

const myxara = new MyxaraClient({
  apiKey: process.env.MYXARA_API_KEY!
})

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY!
})

// Create support inbox
const inbox = await myxara.inboxes.create({
  local_part: 'support',
  name: 'AI Support Agent',
  metadata: {
    type: 'customer_support',
    auto_reply: true
  }
})

// Set up webhook for real-time responses
const webhook = await myxara.webhooks.create({
  url: 'https://your-server.com/webhook',
  events: ['message.received'],
  inbox_id: inbox.id
})

// Handle incoming emails
app.post('/webhook', async (req, res) => {
  const { message } = req.body.data

  // Generate AI response
  const completion = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [
      {
        role: 'system',
        content: 'You are a helpful customer support agent. Be concise and friendly.'
      },
      {
        role: 'user',
        content: message.text
      }
    ]
  })

  // Send AI-generated reply
  await myxara.inboxes.messages(inbox.id).send({
    to: message.from,
    subject: `Re: ${message.subject}`,
    text: completion.choices[0].message.content,
    in_reply_to: message.id
  })

  res.sendStatus(200)
})

View full customer support example →

Lead Nurturing

Create an AI SDR that engages with inbound leads:

// Create sales inbox
const salesInbox = await client.inboxes.create({
  local_part: 'sales',
  name: 'AI Sales Agent',
  metadata: {
    type: 'sales',
    auto_qualify: true
  }
})

// Process incoming leads
const messages = await client.inboxes.messages(salesInbox.id).list({
  direction: 'in'
})

for (const message of messages.data) {
  // Qualify lead with AI
  const qualification = await qualifyLead(message.text)

  if (qualification.score > 80) {
    // High-quality lead - schedule meeting
    await client.inboxes.messages(salesInbox.id).send({
      to: message.from,
      subject: 'Let\'s schedule a demo',
      html: generateMeetingEmail(qualification),
      metadata: {
        lead_score: qualification.score,
        qualified: true
      }
    })
  } else {
    // Nurture lead
    await client.inboxes.messages(salesInbox.id).send({
      to: message.from,
      subject: 'Learn more about our product',
      html: generateNurtureEmail(),
      metadata: {
        lead_score: qualification.score,
        qualified: false
      }
    })
  }
}

Email Analysis & Routing

Analyze incoming emails and route to appropriate teams:

import { MyxaraClient } from '@myxara/sdk-js'

const client = new MyxaraClient({
  apiKey: process.env.MYXARA_API_KEY!
})

// Analyze and categorize emails
async function analyzeEmail(message: any) {
  // Use AI to categorize
  const category = await categorizeWithAI(message.text)

  // Route to appropriate team
  const routing = {
    'technical_support': 'tech-support@company.com',
    'billing': 'billing@company.com',
    'sales': 'sales@company.com',
    'general': 'info@company.com'
  }

  return {
    category,
    route_to: routing[category] || routing['general'],
    priority: calculatePriority(message),
    sentiment: analyzeSentiment(message.text)
  }
}

// Process inbox
const messages = await client.inboxes.messages(inboxId).list({
  direction: 'in'
})

for (const message of messages.data) {
  const analysis = await analyzeEmail(message)

  console.log(`Category: ${analysis.category}`)
  console.log(`Priority: ${analysis.priority}`)
  console.log(`Sentiment: ${analysis.sentiment}`)
  console.log(`Routing to: ${analysis.route_to}`)

  // Forward to appropriate team
  await forwardToTeam(message, analysis.route_to)
}

Common Patterns

Webhook Handler

Real-time email processing with webhooks:

import express from 'express'
import crypto from 'crypto'

const app = express()
app.use(express.json())

// Verify webhook signature
function verifySignature(signature: string, payload: any, secret: string): boolean {
  const expected = crypto
    .createHmac('sha256', secret)
    .update(JSON.stringify(payload))
    .digest('hex')

  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  )
}

app.post('/webhook', async (req, res) => {
  // Verify signature
  const signature = req.headers['myxara-signature'] as string

  if (!verifySignature(signature, req.body, process.env.WEBHOOK_SECRET!)) {
    return res.status(401).send('Invalid signature')
  }

  const event = req.body

  // Handle event
  if (event.type === 'message.received') {
    await handleIncomingMessage(event.data.message)
  }

  res.sendStatus(200)
})

app.listen(3000)

View full webhook example →

Error Handling

Production-ready error handling:

import {
  MyxaraClient,
  AuthenticationError,
  RateLimitError,
  ValidationError,
  APIError
} from '@myxara/sdk-js'

async function sendEmailSafely(
  inboxId: string,
  to: string,
  subject: string,
  text: string
) {
  try {
    const message = await client.inboxes.messages(inboxId).send({
      to,
      subject,
      text
    })

    return { success: true, message }

  } catch (error) {
    if (error instanceof AuthenticationError) {
      // Log error, alert admin
      console.error('Authentication failed - check API key')
      return { success: false, error: 'auth' }

    } else if (error instanceof RateLimitError) {
      // Queue for retry
      console.log(`Rate limited - retry after ${error.retryAfter}s`)
      return { success: false, error: 'rate_limit', retryAfter: error.retryAfter }

    } else if (error instanceof ValidationError) {
      // Fix input and retry
      console.error('Validation errors:', error.errors)
      return { success: false, error: 'validation', errors: error.errors }

    } else if (error instanceof APIError) {
      // Log to error tracking
      console.error(`API error: ${error.message}`)
      return { success: false, error: 'api', message: error.message }
    }

    throw error
  }
}

View full error handling guide →

Batch Processing

Process multiple emails efficiently:

async function processBatch(inboxId: string, batchSize = 50) {
  let offset = 0
  let hasMore = true

  while (hasMore) {
    // Fetch batch
    const response = await client.inboxes.messages(inboxId).list({
      direction: 'in',
      limit: batchSize,
      offset
    })

    // Process in parallel
    await Promise.all(
      response.data.map(message => processMessage(message))
    )

    // Next batch
    offset += batchSize
    hasMore = response.has_more
  }
}

async function processMessage(message: any) {
  // Your processing logic
  console.log(`Processing ${message.id}`)
}

Testing

Unit Tests

import { describe, it, expect, beforeAll } from 'bun:test'
import { MyxaraClient } from '@myxara/sdk-js'

describe('Myxara Integration', () => {
  let client: MyxaraClient
  let testInbox: any

  beforeAll(async () => {
    client = new MyxaraClient({
      apiKey: process.env.MYXARA_API_KEY!
    })

    // Create test inbox
    testInbox = await client.inboxes.create({
      local_part: `test-${Date.now()}`,
      name: 'Test Inbox'
    })
  })

  it('sends an email', async () => {
    const message = await client.inboxes.messages(testInbox.id).send({
      to: 'test@example.com',
      subject: 'Test Email',
      text: 'This is a test'
    })

    expect(message.id).toBeDefined()
    expect(message.status).toBe('sent')
  })

  it('lists messages', async () => {
    const response = await client.inboxes.messages(testInbox.id).list()

    expect(response.data).toBeInstanceOf(Array)
    expect(response.total).toBeGreaterThanOrEqual(0)
  })
})

Next Steps

• Customer Support Example → - Full AI support agent
• Webhook Example → - Real-time email handling
• SDK Reference → - Complete SDK documentation