DevInbox

Perfect for Automated Testing

Generate disposable emails programmatically and verify email content in your test suites. DevInbox provides a robust API that integrates seamlessly with your existing testing frameworks.

Why Use DevInbox for Integration Testing? Traditional email testing is slow, unreliable, and requires complex setup. DevInbox provides instant, isolated email addresses that work perfectly in automated test environments.

Step 1: Get Your API Key

Before you can use the DevInbox API, you need to obtain an API key from your dashboard.

1. Sign up for a free DevInbox account
2. Navigate to Settings → API Keys
3. Click Generate API Key
4. Copy and store it securely in your test environment

All API requests require authentication via the X-Api-Key header. Keep your API key secure and never commit it to version control.

# Store your API key as environment variable
$ export DEVINBOX_API_KEY="your-api-key-here"

# Or in your test configuration
import os

API_KEY = os.getenv("DEVINBOX_API_KEY")
API_BASE = "https://api.devinbox.io"

# Install the SDK: pip install devinbox-client

# Configure the client
from devinbox_client import Configuration, ApiClient
from devinbox_client.api.mailboxes_api import MailboxesApi
from devinbox_client.api.messages_api import MessagesApi

import os
api_key = os.getenv("DEVINBOX_API_KEY")

configuration = Configuration(
    host="https://api.devinbox.io"
)
configuration.api_key['ApiKey'] = api_key

api_client = ApiClient(configuration)
mailboxes_api = MailboxesApi(api_client)
messages_api = MessagesApi(api_client)

// Store your API key as environment variable
$ export DEVINBOX_API_KEY="your-api-key-here"

// Or in your test configuration
const API_KEY = process.env.DEVINBOX_API_KEY;
const API_BASE = 'https://api.devinbox.io';

// Install the SDK: npm install @dev-inbox/client-api

// Configure the client
import { Configuration, MailboxesApi, MessagesApi } from '@dev-inbox/client-api';

const apiKey = process.env.DEVINBOX_API_KEY;

const configuration = new Configuration({
    basePath: 'https://api.devinbox.io',
    baseOptions: {
        headers: {
            'X-API-Key': apiKey
        }
    }
});

const mailboxesApi = new MailboxesApi(configuration);
const messagesApi = new MessagesApi(configuration);

// Store in appsettings.json or user secrets
{
  "DevInbox": {
    "ApiKey": "your-api-key-here",
    "ApiBase": "https://api.devinbox.io"
  }
}

// Or use environment variables
var apiKey = Environment.GetEnvironmentVariable("DEVINBOX_API_KEY");

// Install the SDK: dotnet add package DevInbox.Client

// Configure in Program.cs or Startup.cs
using DevInbox.Client.Extensions;

var apiKey = Environment.GetEnvironmentVariable("DEVINBOX_API_KEY");

services.AddApi(config =>
{
    config.AddApiHttpClients(client =>
    {
        client.BaseAddress = new Uri("https://api.devinbox.io");
        client.DefaultRequestHeaders.Add("X-Api-Key", apiKey);
    });
});

// Store your API key as environment variable
$ export DEVINBOX_API_KEY="your-api-key-here"

// Or in your test configuration
import "os"

apiKey := os.Getenv("DEVINBOX_API_KEY")
apiBase := "https://api.devinbox.io"

Step 2: Create a Temporary Mailbox

Create a disposable mailbox that will receive your test emails. Each mailbox gets a unique email address and password for SMTP authentication.

Temporary mailboxes are perfect for integration tests that need isolated, thread-safe email addresses.

Optional: You can specify a projectName to organize mailboxes. If not provided, your default project will be used.

SMTP Note: For direct SMTP sending, use the mailbox key (without @devinbox.io) as the username and the password for authentication with smtp.devinbox.io:587.

import requests

API_KEY = "your_api_key"
headers = {"X-Api-Key": API_KEY}

# Create a temporary mailbox (uses default project)
response = requests.post(
    "https://api.devinbox.io/mailboxes",
    headers=headers,
    json={})

# Or specify a project: json={"projectName": "MyProject"}

mailbox = response.json()
print(f"Mailbox Key: {mailbox['key']}")
print(f"Email Address: {mailbox['key']}@devinbox.io")
print(f"Password: {mailbox['password']}"

from devinbox_client.api.mailboxes_api import MailboxesApi
from devinbox_client.models.mailbox_create_model import MailboxCreateModel

# Create a temporary mailbox (uses default project)
mailbox_create_model = MailboxCreateModel()
# Or specify project: mailbox_create_model.project_name = "MyProject"

mailbox = mailboxes_api.create_mailbox(
    mailbox_create_model=mailbox_create_model
)

print(f"Mailbox Key: {mailbox.key}")
print(f"Email Address: {mailbox.key}@devinbox.io")
print(f"Password: {mailbox.password}"

const API_KEY = 'your_api_key';
const headers = { 'X-Api-Key': API_KEY };

// Create a temporary mailbox (uses default project)
const response = await fetch(
    'https://api.devinbox.io/mailboxes',
    {
        method: 'POST',
        headers: {
            ...headers,
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({})
        // Or: body: JSON.stringify({ projectName: 'MyProject' })
    });

const mailbox = await response.json();
console.log(`Mailbox Key: ${mailbox.key}`);
console.log(`Email: ${mailbox.key}@devinbox.io`);

import { MailboxesApi, MailboxCreateModel } from '@dev-inbox/client-api';

// Create a temporary mailbox (uses default project)
const mailboxCreateModel = {};
// Or specify project: const mailboxCreateModel = { projectName: 'MyProject' };

const response = await mailboxesApi.createMailbox(mailboxCreateModel);
const mailbox = response.data;

console.log(`Mailbox Key: ${mailbox.key}`);
console.log(`Email: ${mailbox.key}@devinbox.io`);
console.log(`Password: ${mailbox.password}`);

using System.Net.Http;
using System.Text;
using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key", "your_api_key");

// Create a temporary mailbox (uses default project)
var payload = new { };
// Or specify project: var payload = new { projectName = "MyProject" };

var content = new StringContent(
    JsonSerializer.Serialize(payload),
    Encoding.UTF8,
    "application/json");

var response = await client.PostAsync(
    "https://api.devinbox.io/mailboxes", content);
var mailbox = await response.Content.ReadFromJsonAsync<dynamic>();

Console.WriteLine($"Email: {mailbox.key}@devinbox.io");

using DevInbox.Client.Api;
using DevInbox.Client.Model;

// Inject IMailboxesApi from DI container
var mailboxesApi = serviceProvider.GetRequiredService<IMailboxesApi>();

// Create a temporary mailbox (uses default project)
var mailboxCreateModel = new MailboxCreateModel();
// Or specify project: mailboxCreateModel.ProjectName = "MyProject";

var response = await mailboxesApi.CreateMailboxAsync(mailboxCreateModel);

if (response.IsOk)
{
    var mailbox = response.Ok();
    Console.WriteLine($"Email: {mailbox.Key}@devinbox.io");
    Console.WriteLine($"Password: {mailbox.Password}");
}

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

// Create empty payload (uses default project)
payload := map[string]string{}
// Or specify project: payload := map[string]string{"projectName": "MyProject"}
jsonData, _ := json.Marshal(payload)

req, _ := http.NewRequest("POST",
    "https://api.devinbox.io/mailboxes",
    bytes.NewBuffer(jsonData))
req.Header.Set("X-Api-Key", "your_api_key")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)

Step 3: Trigger Your Application

Now that you have a mailbox, you have two options to send emails that will be captured by DevInbox:

Option 1: Configure SMTP Server in Your Application

Configure your application's SMTP settings to use DevInbox's SMTP server with the credentials returned by the Create Mailbox API. Set the SMTP server to smtp.devinbox.io:587, use the mailbox key as the username, and the password for authentication. Your application can then send emails to any recipient address, and all emails will be captured by DevInbox and delivered to your mailbox.

Option 2: Send Directly to Mailbox Address

Alternatively, you can configure your application to send emails directly to the mailbox address ({'{key}'}@devinbox.io). Any emails sent to this address will be automatically captured by DevInbox.

Pro tip: Add a small delay (100-500ms) after triggering your application to ensure the email has been delivered before checking for it.

import time
import smtplib
from email.mime.text import MIMEText

# Option 1: Configure your app's SMTP server with DevInbox credentials
# Configure your app to use smtp.devinbox.io:587 with mailbox key/password
# All emails sent by your app will be captured by DevInbox
smtp_server = "smtp.devinbox.io"
smtp_port = 587
username = mailbox['key']  # Use key as username
password = mailbox['password']  # Use returned password

# Your app can now send emails normally - they'll all be captured
with smtplib.SMTP(smtp_server, smtp_port) as server:
    server.starttls()
    server.login(username, password)
    # Send to any recipient - all emails are captured by DevInbox
    server.sendmail(username, "any-recipient@example.com", "Test email body")

# Option 2: Send directly to the mailbox address
# Configure your app to send emails to key@devinbox.io
test_email = f"{mailbox['key']}@devinbox.io"
your_app.register_user(
    email=test_email,
    name="John Doe")

# Wait for email delivery
time.sleep(0.3)  # 300ms

import time
import smtplib
from email.mime.text import MIMEText

# Use mailbox from SDK response

# Option 1: Configure your app's SMTP server with DevInbox credentials
# Configure your app to use smtp.devinbox.io:587 with mailbox key/password
# All emails sent by your app will be captured by DevInbox
smtp_server = "smtp.devinbox.io"
smtp_port = 587
username = mailbox.key  # Use key as username
password = mailbox.password  # Use returned password

# Your app can now send emails normally - they'll all be captured
with smtplib.SMTP(smtp_server, smtp_port) as server:
    server.starttls()
    server.login(username, password)
    # Send to any recipient - all emails are captured by DevInbox
    server.sendmail(username, "any-recipient@example.com", "Test email body")

# Option 2: Send directly to the mailbox address
# Configure your app to send emails to key@devinbox.io
test_email = f"{mailbox.key}@devinbox.io"
your_app.register_user(
    email=test_email,
    name="John Doe")

# Wait for email delivery
time.sleep(0.3)  # 300ms

const nodemailer = require('nodemailer');

// Option 1: Configure your app's SMTP server with DevInbox credentials
// Configure your app to use smtp.devinbox.io:587 with mailbox key/password
// All emails sent by your app will be captured by DevInbox
const transporter = nodemailer.createTransport({
    host: 'smtp.devinbox.io',
    port: 587,
    secure: false,
    auth: {
        user: mailbox.key,  // Use key as username
        pass: mailbox.password  // Use returned password
    }
});

// Your app can now send emails normally - they'll all be captured
// Send to any recipient - all emails are captured by DevInbox
await transporter.sendMail({
    from: mailbox.key,
    to: 'any-recipient@example.com',
    subject: 'Test Email',
    text: 'Test email body'
});

// Option 2: Send directly to the mailbox address
// Configure your app to send emails to key@devinbox.io
const testEmail = `${mailbox.key}@devinbox.io`;
await yourApp.registerUser({
    email: testEmail,
    name: 'John Doe'
});

// Wait for email delivery
await new Promise(r => setTimeout(r, 300)); // 300ms

const nodemailer = require('nodemailer');

// Use mailbox from SDK response
const mailbox = response.data;

// Option 1: Configure your app's SMTP server with DevInbox credentials
// Configure your app to use smtp.devinbox.io:587 with mailbox key/password
// All emails sent by your app will be captured by DevInbox
const transporter = nodemailer.createTransport({
    host: 'smtp.devinbox.io',
    port: 587,
    secure: false,
    auth: {
        user: mailbox.key,  // Use key as username
        pass: mailbox.password  // Use returned password
    }
});

// Your app can now send emails normally - they'll all be captured
// Send to any recipient - all emails are captured by DevInbox
await transporter.sendMail({
    from: mailbox.key,
    to: 'any-recipient@example.com',
    subject: 'Test Email',
    text: 'Test email body'
});

// Option 2: Send directly to the mailbox address
// Configure your app to send emails to key@devinbox.io
const testEmail = `${mailbox.key}@devinbox.io`;
await yourApp.registerUser({
    email: testEmail,
    name: 'John Doe'
});

// Wait for email delivery
await new Promise(r => setTimeout(r, 300)); // 300ms

using System.Net.Mail;

// Option 1: Configure your app's SMTP server with DevInbox credentials
// Configure your app to use smtp.devinbox.io:587 with mailbox key/password
// All emails sent by your app will be captured by DevInbox
using var smtpClient = new SmtpClient("smtp.devinbox.io", 587)
{
    EnableSsl = true,
    Credentials = new System.Net.NetworkCredential(
        mailbox.key,  // Use key as username
        mailbox.password  // Use returned password
    )
};

// Your app can now send emails normally - they'll all be captured
// Send to any recipient - all emails are captured by DevInbox
var mailMessage = new MailMessage(mailbox.key, "any-recipient@example.com")
{
    Subject = "Test Email",
    Body = "Test email body"
};
await smtpClient.SendMailAsync(mailMessage);

// Option 2: Send directly to the mailbox address
// Configure your app to send emails to key@devinbox.io
var testEmail = $"{mailbox.key}@devinbox.io";
await yourApp.RegisterUserAsync(
    email: testEmail,
    name: "John Doe");

// Wait for email delivery
await Task.Delay(300); // 300ms

using System.Net.Mail;

// Use mailbox from SDK response
var mailbox = response.Ok();

// Option 1: Configure your app's SMTP server with DevInbox credentials
// Configure your app to use smtp.devinbox.io:587 with mailbox key/password
// All emails sent by your app will be captured by DevInbox
using var smtpClient = new SmtpClient("smtp.devinbox.io", 587)
{
    EnableSsl = true,
    Credentials = new System.Net.NetworkCredential(
        mailbox.Key,  // Use key as username
        mailbox.Password  // Use returned password
    )
};

// Your app can now send emails normally - they'll all be captured
// Send to any recipient - all emails are captured by DevInbox
var mailMessage = new MailMessage(mailbox.Key, "any-recipient@example.com")
{
    Subject = "Test Email",
    Body = "Test email body"
};
await smtpClient.SendMailAsync(mailMessage);

// Option 2: Send directly to the mailbox address
// Configure your app to send emails to key@devinbox.io
var testEmail = $"{mailbox.Key}@devinbox.io";
await yourApp.RegisterUserAsync(
    email: testEmail,
    name: "John Doe");

// Wait for email delivery
await Task.Delay(300); // 300ms

import "time"
import "net/smtp"

// Option 1: Configure your app's SMTP server with DevInbox credentials
// Configure your app to use smtp.devinbox.io:587 with mailbox key/password
// All emails sent by your app will be captured by DevInbox
smtpServer := "smtp.devinbox.io:587"
auth := smtp.PlainAuth("", mailbox.Key, mailbox.Password, "smtp.devinbox.io")

// Your app can now send emails normally - they'll all be captured
// Send to any recipient - all emails are captured by DevInbox
msg := []byte("To: any-recipient@example.com\r\n" +
    "Subject: Test Email\r\n" +
    "\r\n" +
    "Test email body\r\n")
err := smtp.SendMail(smtpServer, auth, mailbox.Key, []string{"any-recipient@example.com"}, msg)

// Option 2: Send directly to the mailbox address
// Configure your app to send emails to key@devinbox.io
testEmail := fmt.Sprintf("%s@devinbox.io", mailbox.Key)
yourApp.RegisterUser(
    email: testEmail,
    name: "John Doe")

// Wait for email delivery
time.Sleep(300 * time.Millisecond)

Step 4: Verify the Email

Retrieve and verify the email from your mailbox. You can check the subject, body, sender, and any other email properties your test requires.

Use /single when you expect exactly one email, or /last to get the most recent email.

# Get the single message (fails if 0 or >1 messages)
response = requests.get(
    f"https://api.devinbox.io/messages/{mailbox['key']}/single",
    headers=headers)

message = response.json()

# Verify email content
assert "Welcome" in message['subject']
assert "John Doe" in message['body']
assert message['from'][0] == "noreply@yourapp.com"

print("✓ Email verification passed!"

from devinbox_client.api.messages_api import MessagesApi

# Get the single message (fails if 0 or >1 messages)
message = messages_api.get_single_message(key=mailbox.key)

# Verify email content
assert "Welcome" in message.subject
assert "John Doe" in message.body
assert message.var_from and message.var_from[0] == "noreply@yourapp.com"

print("✓ Email verification passed!"

// Get the single message (fails if 0 or >1 messages)
const response = await fetch(
    `https://api.devinbox.io/messages/${mailbox.key}/single`,
    { headers });

const message = await response.json();

// Verify email content
expect(message.subject).toContain('Welcome');
expect(message.body).toContain('John Doe');
expect(message.from[0]).toBe('noreply@yourapp.com');

console.log('✓ Email verification passed!');

import { MessagesApi } from '@dev-inbox/client-api';

// Get the single message (fails if 0 or >1 messages)
const response = await messagesApi.getSingleMessage(mailbox.key);
const message = response.data;

// Verify email content
expect(message.subject).toContain('Welcome');
expect(message.body).toContain('John Doe');
expect(message.from && message.from[0]).toBe('noreply@yourapp.com');

console.log('✓ Email verification passed!');

// Get the single message (fails if 0 or >1 messages)
var response = await client.GetAsync(
    $"https://api.devinbox.io/messages/{mailbox.key}/single");

var message = await response
    .Content.ReadFromJsonAsync<dynamic>();

// Verify email content
Assert.Contains("Welcome", message.subject.ToString());
Assert.Contains("John Doe", message.body.ToString());
Assert.Equal("noreply@yourapp.com", message.from[0].ToString());

Console.WriteLine("✓ Email verification passed!");

using DevInbox.Client.Api;

// Inject IMessagesApi from DI container
var messagesApi = serviceProvider.GetRequiredService<IMessagesApi>();

// Get the single message (fails if 0 or >1 messages)
var response = await messagesApi.GetSingleMessageAsync(mailbox.Key);

if (response.IsOk)
{
    var message = response.Ok();

    // Verify email content
    Assert.Contains("Welcome", message.Subject);
    Assert.Contains("John Doe", message.Body);
    Assert.NotNull(message.From);
    Assert.Equal("noreply@yourapp.com", message.From![0]);

    Console.WriteLine("✓ Email verification passed!");
}

// Get the single message (fails if 0 or >1 messages)
url := fmt.Sprintf(
    "https://api.devinbox.io/messages/%s/single",
    mailbox.Key)

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("X-Api-Key", apiKey)

resp, _ := client.Do(req)
var message Message
json.NewDecoder(resp.Body).Decode(&message)

// Verify email content
assert.Contains(t, message.Subject, "Welcome")
assert.Contains(t, message.Body, "John Doe"