Developer Documentation

MailSlurp has an official Javascript client published on npm.

Install

Add the MailSlurp dependency to your test project.

npm install -s mailslurp-client

Instantiate

Create a new MailSlurp Client with your API Key.

const MailSlurpClient = require('mailslurp-client')
const mailslurp = new MailSlurpClient({ apiKey: 'your-api-key' })

Create a private email address

const { id, emailAddress} = await api.createNewEmailAddress()

Send an email from random address

More options available. See package docs.

await api.sendEmailSimple({ 
    // required
    to: ['array-of-email-addresses'], 
    // optional
    subject: '',
    body: '',
    cc: [],
    bcc: [],
    html: false
})

Receive email to a known address

Assumes the emailAddress specified is empty of messages.

const { to, body, subject } = await 
    api.fetchLatestEmail(inboxEmailAddress: '123@mailslurp.com');

Common methods

// create a new email address and return { id: string, emailAdress: string }
createNewEmailAddress(): Promise<Inbox>;
 
// send an email from a randomly generated email address
// to send from a know address see advanced operations
// sendEmailOptions must include recipients, subject and body
// for more options see SendEmailOptions definiton
// { to: string[], subject: string, body: string }
sendEmailSimple(sendEmailOptions: SendEmailOptions);
 
// get the latest email in an inbox or if empty wait for one to arrive
// must provide either inboxId or emailAddress of an inbox you have created
// for waiting on emails in non-empty inboxes see advanced operations
fetchLatestEmail(inboxEmailAddress?: string, inboxId?: string): Promise<Email>;

Create a new email and sign up user

const MailSlurpClient = require('mailslurp-client')
const mailslurp = new MailSlurpClient({ apiKey: 'your-api-key' })
 
let emailAddress;
 
test('can signup user', async () => {
    emailAddress = await mailslurp.createNewEmailAddress()
    const status = await myApplication.signUpUser(emailAddress)
    expect(status).to.equal(201)
})
 
test('user receives welcome email', async () => {
    const { subject, body } = await mailslurp.fetchLatestEmail(emailAddress)
    expect(subject).to.contain("Welcome to my app!")
    expect(body).to.contain("Thank you for joining")
    // can also use body to extract verification codes with regex capture
}) 

Send an email from unique address

const MailSlurpClient = require('mailslurp-client')
const mailslurp = new MailSlurpClient({ apiKey: 'your-api-key' })
 
test('can send email to my app', async () => {
    await mailslurp.sendEmailSimple({ 
        to: ['my-app@app.com'],
        subject: 'Hello support',
        body: '' 
    })
})
 
test('my app reacted to sent email', async () => {
    const handledEmail = await testAppReceivedEmail()
    expect(handledEmail).to.equal(true)
})

You can install the MailSlurp client via pypi with pip. See Github for full python documentation.

pip install mailslurp-api-python-client

Create instance

import mailslurp_api_python_client

configuration = mailslurp_api_python_client.Configuration()
configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
client = mailslurp_api_python_client.ApiClient(configuration)

api_instance = mailslurp_api_python_client.CommonOperationsApi(client)

Create a unique email address

api_response = api_instance.create_new_email_address_using_post()

Send email from random address

send_email_options = mailslurp_api_python_client.SendEmailOptions()
send_email_options["to"] = ["test@example.com"]

api_instance.send_email_using_post(send_email_options)

Receive email with known address

 api_response = api_instance.fetch_latest_email_using_get(inbox_email_address="123@mailslurp.com")

The MailSlurp Java SDK is hosted on JitPack. Full Java Documentation on Github.

Gradle installation

Add the repository

allprojects {
  repositories {
    ...
    maven { url 'https://jitpack.io' }
  }
}

dependencies {
  implementation 'com.github.mailslurp:swagger-sdk-java:900a94e754'
}

Maven installation

<repositories>
  <repository>
    <id>jitpack.io</id>
    <url>https://jitpack.io</url>
  </repository>
</repositories>

<dependency>
  <groupId>com.github.mailslurp</groupId>
  <artifactId>swagger-sdk-java</artifactId>
  <version>0843e2040e</version>
</dependency>

Create and configure client

import mailslurp.*;
import mailslurp.auth.*;
import mailslurpmodels.*;

ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setConnectTimeout(60000);

// Configure API key authorization: API_KEY
ApiKeyAuth API_KEY = (ApiKeyAuth) defaultClient.getAuthentication("API_KEY");
API_KEY.setApiKey("YOUR API KEY");

CommonOperationsApi apiInstance = new CommonOperationsApi()

Create new email address

Inbox result = apiInstance.createNewEmailAddressUsingPOST();

Send real email from random address

List<String> recipients = new ArrayList();
recipients.add("test@example.com");

SendEmailOptions sendEmailOptions = new SendEmailOptions();
sendEmailOptions.setTo(recipients);

apiInstance.sendEmailSimpleUsingPOST(sendEmailOptions);

Receive email with a created email address

String inboxEmailAddress = "123@mailslurp.com"; 
Email result = apiInstance.fetchLatestEmailUsingGET(inboxEmailAddress, null);

You can install MailSlurp with Composer and Packagist. See Packagist for full php documentation.

composer require mailslurp/swagger-sdk-php

Getting started

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: API_KEY
$config = MailSlurpSDK\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');

$apiInstance = new MailSlurpSDK\Api\CommonOperationsApi(
    new GuzzleHttp\Client(),
    $config
);

Create new email address

$result = $apiInstance->createNewEmailAddressUsingPOST();

Send real email from random address

$options = new \MailSlurpSDK\MailSlurpModels\SendEmailOptions();
$options["to"] = array("test@example.com")

$apiInstance->sendEmailSimpleUsingPOST($options);

Receive email from known address

$result = $apiInstance->fetchLatestEmailUsingGET("123@mailslurp.com");

You can use MailSlurp with Ruby Gems.

Install

gem install mailslurp-client

Configure

require 'mailslurp-client'

MailSlurpClient.configure do |config|
  config.api_key['x-api-key'] = 'YOUR API KEY'
end

Create a unique email address

api_instance = MailSlurpClient::CommonOperationsApi.new
result = api_instance.create_new_email_address_using_post

Send real email from random address

api_instance = MailSlurpClient::CommonOperationsApi.new

send_email_options = MailSlurpClient::SendEmailOptions.new
send_email_options['to'] = ['test@example.com']

api_instance.send_email_simple_using_post(send_email_options)

Receive email with known address

api_instance = MailSlurpClient::CommonOperationsApi.new

opts = { 
  inbox_email_address: '123@mailslurp.com'
}

result = api_instance.fetch_latest_email_using_get(opts)
p result.body

Use in Rspec test

RSpec.describe 'client' do
  it 'can create email address' do
    require 'mailslurp-client'

    MailSlurpClient.configure do |config|
      config.api_key['x-api-key'] = 'YOUR API KEY'
    end

    api_instance = MailSlurpClient::CommonOperationsApi.new

    result = api_instance.create_new_email_address_using_post
    expect(result.email_address).to include("mailslurp.com")
  end
end

MailSlurp can be called from scripts and CI pipelines via an HTTP REST API. For all endpoints and responses see REST API documentation.

You can also build your own library from the OpenAPI / SwaggerSpecs in many different languages.

Examples

Create an email address

Will create a new private email address and return the id and emailAddress.

curl -X POST api.mailslurp.com/newEmailAddress -H 'x-api-key:test'

Send email from random address

curl -X POST api.mailslurp.com/sendEmail -d '{ "to": ["test@example.com"] }' -H 'content-type: application/json' -H 'x-api-key:test'

Receive email with a known address

curl 'api.mailslurp.com/fetchLatestEmail?inboxEmailAddress=123@mailslurp.com' -H 'x-api-key:test'