MailSlurp

https://www.mailslurp.com/docs/
Admin
MailSlurp is an email and SMS platform for developers, QA testers, and marketing teams to create...
Tokens:151,055
Snippets:1,684
Trust Score:9.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Full Test Usage Example

Source: https://www.mailslurp.com/docs/dart.md

A comprehensive example demonstrating setup, API key configuration from environment variables, and testing email creation, sending, and receiving using MailSlurp controllers.

```dart
import 'dart:io';

import 'package:test/test.dart';
import 'package:mailslurp/api.dart';

void main() async {
  setUp(() {
    // read api key from environment variable
    var apiKey = Platform.environment["API_KEY"];
    expect(apiKey != null, true);

    // set api key and instantiate controllers
    defaultApiClient.getAuthentication<ApiKeyAuth>('API_KEY').apiKey = apiKey;
  });

  test('can create email addresses', () async {
    var inboxController = InboxControllerApi();
    var inbox = await inboxController.createInboxWithOptions(CreateInboxDto());
    expect(inbox.emailAddress.contains("@mailslurp"), true);
  });

  test('can send and receive emails', () async {
    var inboxController = InboxControllerApi();
    var waitForController = WaitForControllerApi();

    var inbox = await inboxController.createInboxWithOptions(CreateInboxDto());

    var confirmation = await inboxController.sendEmailAndConfirm(inbox.id,
        sendEmailOptions: SendEmailOptions(
            to: [inbox.emailAddress],
            subject: "Test email",
            body: "<html>My message</html>",
            isHTML: true
        )
    );
    expect(confirmation.inboxId, inbox.id);

    var email = await waitForController.waitForLatestEmail(inboxId: inbox.id, timeout: 30000, unreadOnly: true);
    expect(email.subject, "Test email");
  });
}
```

--------------------------------

### Install MailSlurp Go Client

Source: https://www.mailslurp.com/docs/go.md

Install the MailSlurp Go client library using go get. Ensure you also install necessary dependencies like golang.org/x/oauth2 and github.com/antihax/optional.

```bash
go get github.com/mailslurp/mailslurp-client-go

go get golang.org/x/oauth2
go get golang.org/x/net/context
go get github.com/antihax/optional
```

--------------------------------

### PHP Composer PHPUnit Example Project

Source: https://www.mailslurp.com/docs/phpunit.md

Link to an example project demonstrating PHPUnit integration with Composer.

```link
https://github.com/mailslurp/examples/tree/master/php-composer-phpunit
```

--------------------------------

### Install Bundler and Dependencies

Source: https://www.mailslurp.com/docs/ruby.md

Install the Bundler package manager and then run 'bundle install' to install all gems specified in your Gemfile, including the MailSlurp client.

```bash
gem install bundler
bundle install
```

--------------------------------

### PHP Laravel PHPUnit Example Project

Source: https://www.mailslurp.com/docs/phpunit.md

Link to an example project demonstrating PHPUnit integration with Laravel.

```link
https://github.com/mailslurp/examples/tree/master/php-laravel-phpunit
```

--------------------------------

### Run Java SDK JUnit Example

Source: https://www.mailslurp.com/docs/mulesoft.md

Navigate to the Java SDK JUnit example directory, set your MailSlurp API key, and run the tests using Maven.

```bash
cd examples/mulesoft-anypoint-java-selenium-test

export MAILSLURP_API_KEY=your_api_key_here
mvn test
```

--------------------------------

### Install graphql-request Library

Source: https://www.mailslurp.com/docs/graphql.md

Install the necessary graphql-request library for Node.js projects to interact with the MailSlurp GraphQL API.

```bash
npm install --save graphql-request
```

--------------------------------

### Send and Receive Email with MailSlurp Ruby SDK

Source: https://www.mailslurp.com/docs/ruby.md

This example demonstrates creating two inboxes, sending an email from one to the other, and then waiting for the email to arrive. It requires the MailSlurp Ruby SDK to be installed and an API key to be set as an environment variable.

```ruby
require 'mailslurp_client'

# read mailslurp api key from environment variables
API_KEY = ENV['API_KEY']

describe 'use MailSlurp ruby sdk to create email addresses then send and receive email' do
  before(:all) do
    expect(API_KEY).to be_truthy

    # configure mailslurp with API key
    MailSlurpClient.configure do |config|
      config.api_key['x-api-key'] = API_KEY
    end
  end

  it 'can an inbox with an email address' do
    # create a new email address
    inbox_controller = MailSlurpClient::InboxControllerApi.new
    inbox = inbox_controller.create_inbox

    # has a mailslurp email address
    expect(inbox.id).to be_truthy
    expect(inbox.email_address).to include('@mailslurp.com')
  end

  it 'can send and receive emails' do
    inbox_controller = MailSlurpClient::InboxControllerApi.new
    wait_controller  = MailSlurpClient::WaitForControllerApi.new

    # create two inboxes
    inbox_1 = inbox_controller.create_inbox
    inbox_2 = inbox_controller.create_inbox

    # send email from inbox 1 to inbox 2 (you can send emails to any address)
    # for send options see https://ruby.mailslurp.com/MailSlurpClient/SendEmailOptions.html
    opts = {
      send_email_options: MailSlurpClient::SendEmailOptions.new(
        {
          to: [inbox_2.email_address],
          subject: 'Test email',
          from: inbox_1.email_address,
          body: 'Test email content',
          is_html: true
        }
      )
    }
    inbox_controller.send_email(inbox_1.id, opts)

    expect(inbox_2.id).to be_truthy

    # now wait for the email to arrive
    wait_opts = {
      inbox_id: inbox_2.id,
      timeout: 30_000,
      unread_only: true
    }
    email = wait_controller.wait_for_latest_email(wait_opts)
    expect(email.body).to include('Test email content')
  end
end
```

--------------------------------

### Clone and Run Mulesoft MUnit Example

Source: https://www.mailslurp.com/docs/mulesoft.md

Clone the Mulesoft MUnit example project from GitHub, set your MailSlurp API key, and run the tests using Maven.

```bash
git clone https://github.com/mailslurp/examples.git
cd examples/mulesoft-anypoint-munit-otp-test

# Set API key
export MAILSLURP_API_KEY=your_api_key_here

# Run tests
mvn test

# Open in Anypoint Studio
# File → Import → Anypoint Studio project from File System
```

--------------------------------

### HTTP Request Example with Specific Parameters

Source: https://www.mailslurp.com/docs/browserstack

An example of an HTTP GET request to `waitForLatestEmail` with a specified inbox ID, timeout, and unread filter. This is useful for testing email verification flows.

```HTTP
GET https://api.mailslurp.com/waitForLatestEmail?inboxId=INBOX_ID&timeout=120000&unreadOnly=true
x-api-key: YOUR_API_KEY
Accept: application/json


```

--------------------------------

### Install CPANminus

Source: https://www.mailslurp.com/docs/perl.md

Install the CPANminus module, a prerequisite for installing other Perl modules from CPAN.

```bash
cpan App::cpanminus
```

--------------------------------

### Install MailSlurp PHP SDK

Source: https://www.mailslurp.com/docs/phpunit.md

Install the MailSlurp PHP client using Composer. This is a development dependency.

```bash
composer require --dev mailslurp/mailslurp-client-php
```

--------------------------------

### WebdriverIO Example: Email OTP Verification Flow

Source: https://www.mailslurp.com/docs/webdriverio.md

This example demonstrates a complete sign-up flow using WebdriverIO and MailSlurp. It includes creating an inbox, filling out a sign-up form, waiting for an OTP email, extracting the code, and submitting it for verification.

```javascript
import { MailSlurp } from "mailslurp-client";

const mailslurp = new MailSlurp({ apiKey: process.env.API_KEY });

describe("sign up flow", () => {
  it("verifies an email OTP", async () => {
    const inbox = await mailslurp.createInbox();

    await browser.url("https://your-app.example/sign-up");
    await $('input[name="email"]').setValue(inbox.emailAddress);
    await $('input[name="password"]').setValue("correct horse battery staple");
    await $('button[type="submit"]').click();

    const email = await mailslurp.waitController.waitForLatestEmail({
      inboxId: inbox.id,
      timeout: 120000,
      unreadOnly: true,
    });

    const match = await mailslurp.emailController.getEmailContentMatch({
      emailId: email.id,
      contentMatchOptions: {
        pattern: "(?:verification code|OTP|code)[:\\s-]*(\\d{6})",
      },
    });

    await $('input[name="verificationCode"]').setValue(match.matches[1]);
    await $('button[type="submit"]').click();

    await expect($('[data-test="dashboard"]')).toBeDisplayed();
  });
});
```

--------------------------------

### MailSlurp C# Client Example

Source: https://www.mailslurp.com/docs/csharp.md

This snippet shows how to configure the MailSlurp client, create new email inboxes, send an email from one inbox to another, and then receive and assert the content of the sent email. It includes setup, sending, and receiving logic.

```csharp
// create client
var config = new Configuration();
config.ApiKey.Add("x-api-key", ApiKey);

// create inboxes
var inboxControllerApi = new InboxControllerApi(config);
var inbox1 = inboxControllerApi.CreateInbox();
var inbox2 = inboxControllerApi.CreateInbox();

// send email
inboxControllerApi.SendEmail(inbox1.Id, new SendEmailOptions(
    to: new List<string> { inbox2.EmailAddress },
    subject: "Test CSharp",
    body: "<span>Hello</span>",
    isHTML: true
));

// receive email with wait controller
var email = new WaitForControllerApi(config).WaitForLatestEmail(inbox2.Id, 60000, true);
StringAssert.Contains(email.Body, "Hello");

// list emails in inbox
var emails = inboxControllerApi.GetInboxEmailsPaginated(inbox2.Id);
Assert.AreEqual(emails.TotalElements, 1);
```

--------------------------------

### Install MailSlurp NuGet Package with .NET CLI

Source: https://www.mailslurp.com/docs/csharp-netstandard-2x.md

Install the MailSlurp C# library using the .NET CLI. Ensure you run `dotnet restore` after adding the package.

```bash
dotnet add package mailslurp_netstandard_2x
dotnet restore
```

--------------------------------

### Install MailSlurp Packages

Source: https://www.mailslurp.com/docs/codeceptjs.md

Install the necessary MailSlurp packages for CodeceptJS. These include the MailSlurp helper and the MailSlurp client.

```bash
npm i @codeceptjs/mailslurp-helper mailslurp-client --save-dev
```

--------------------------------

### Install MailSlurp Javascript Client

Source: https://www.mailslurp.com/docs/js.md

Install the MailSlurp client using npm or yarn. This is the first step to integrating MailSlurp into your project.

```bash
npm install --save mailslurp-client
```

```bash
yarn add mailslurp-client
```

--------------------------------

### JavaScript GraphQL Client

Source: https://www.mailslurp.com/docs/graphql.md

This example demonstrates how to set up a GraphQL client in JavaScript using the `graphql-request` library to interact with the MailSlurp GraphQL API.

```APIDOC
## JavaScript GraphQL Client Setup

### Description
This code snippet shows how to create a reusable GraphQL client instance for the MailSlurp API using the `graphql-request` library in JavaScript. It ensures your API key is included in the request headers.

### Usage
1. Install the library: `npm install --save graphql-request`
2. Use the `getClient` function, passing your API key.

### Code Example
```javascript
import { GraphQLClient } from "graphql-request";

export function getClient(apiKey) {
  if (!apiKey) {
    throw "Please set missing API_KEY"
  }
  // create a new graphql-request client using the MailSlurp graphql endpoint
  // and passing a headers map including your MailSlurp API Key using "x-api-key" header
  return new GraphQLClient('https://graphql.mailslurp.com', {
    headers: {
      'x-api-key': apiKey,
    },
  });
}
```

### Parameters
#### Function Parameters
- **apiKey** (string) - Required - Your MailSlurp API key.
```

--------------------------------

### Install MailSlurp Ruby Gem

Source: https://www.mailslurp.com/docs/ruby.md

Install the MailSlurp Ruby client gem using the gem command. This is the primary method for adding the client to your project.

```bash
gem install mailslurp_client
```

--------------------------------

### Generate Go gRPC Code with Protobuf

Source: https://www.mailslurp.com/docs/protobuf.md

Use the protobuf compiler to generate Go gRPC service and model code. Ensure `protoc-gen-go` is installed.

```bash
# assuming `protoc-gen-go` has been installed with `go get -u github.com/golang/protobuf/protoc-gen-go`
mkdir /var/tmp/go/
protoc --go_out=/var/tmp/go/ services/*
protoc --go_out=/var/tmp/go/ models/*
```

--------------------------------

### Install MailSlurp with Erlang.mk

Source: https://www.mailslurp.com/docs/elixir.md

Define the MailSlurp dependency using `hex` and its version in your `erlang.mk` file.

```text
dep_mailslurp = hex 11.6.0
```

--------------------------------

### Install MailSlurp with Mix.exs

Source: https://www.mailslurp.com/docs/elixir.md

Add the MailSlurp dependency to your Mix project's `mix.exs` file. Replace the version with the latest from hex.pm.

```elixir
{:mailslurp, "~> 11.6"}
```

--------------------------------

### JavaScript SDK for Email Content Match

Source: https://www.mailslurp.com/docs/browserstack

Example using the MailSlurp JavaScript SDK to get email content matches. Ensure you have the 'mailslurp-client' package installed and configured with your API key.

```JavaScript
import { Configuration, EmailControllerApi } from "mailslurp-client";

const config = new Configuration({ apiKey: "YOUR_API_KEY" });
const emailController = new EmailControllerApi(config);
const request = {
  "emailId": "00000000-0000-4000-8000-000000000000",
  "contentMatchOptions": {
    "pattern": "value"
  }
};

const result = await emailController.getEmailContentMatch(request);
```

--------------------------------

### Initialize Swift Project

Source: https://www.mailslurp.com/docs/swift.md

Use this command to create a new executable Swift project.

```bash
swift package init --type=executable
```

--------------------------------

### PHP SDK Example

Source: https://www.mailslurp.com/docs/overview.md

Demonstrates creating inboxes, sending an email, waiting for it, and listing emails using the PHP SDK. Ensure your API key is set as an environment variable.

```php
// configure client with api key
$config = MailSlurp\Configuration::getDefaultConfiguration()
    ->setApiKey('x-api-key', getenv('API_KEY'));

// create an inbox controller with config
$inboxController = new MailSlurp\Apis\InboxControllerApi(null, $config);

// create inboxes
$inbox1 = $inboxController->createInbox();
$inbox2 = $inboxController->createInbox();

// send an email
$inboxController->sendEmail($inbox1->getId(), new \MailSlurp\Models\SendEmailOptions(array(
    'to' => array($inbox2->getEmailAddress()),
    'subject' => 'Test email',
    'body' => '<span>Hello 👋',
    'is_html' => true
)));

// wait for email
$waitForController = new MailSlurp\Apis\WaitForControllerApi(null, $config);
$email = $waitForController->waitForLatestEmail($inbox2->getId(), 60000, true);
PHPUnit\Framework\Assert::assertStringContainsString("Hello", $email->getBody());

// list emails in inbox
$emails = $inboxController->getInboxEmailsPaginated($inbox2->getId());
PHPUnit\Framework\Assert::assertEquals(1, $emails->getTotalElements());
```

--------------------------------

### Go MailSlurp SDK Example

Source: https://www.mailslurp.com/docs/overview.md

Create a MailSlurp client, set up context, create inboxes, send an email, wait for the latest email, and list emails in Go.

```go
// create a context with your api key
ctx := context.WithValue(context.Background(), mailslurp.ContextAPIKey, mailslurp.APIKey{Key: apiKey})

// create mailslurp client
client := mailslurp.NewAPIClient(mailslurp.NewConfiguration())

// create inboxes
inbox1, _, err := client.InboxControllerApi.CreateInbox(ctx, &mailslurp.CreateInboxOpts{})
inbox2, _, err := client.InboxControllerApi.CreateInbox(ctx, &mailslurp.CreateInboxOpts{})
assert.Nil(t, err)

// send email from inbox 1 to inbox 2
_, err = client.InboxControllerApi.SendEmail(ctx, inbox1.Id, mailslurp.SendEmailOptions{
	To:      []string{inbox2.EmailAddress},
	Subject: "Test",
	Body:    "<span>Hello",
	IsHTML:  true,
})
assert.Nil(t, err)

// now receive the email at inbox 2
email, _, err := client.WaitForControllerApi.WaitForLatestEmail(ctx, &mailslurp.WaitForLatestEmailOpts{
	InboxId:    optional.NewInterface(inbox2.Id),
	Timeout:    optional.NewInt64(60000),
	UnreadOnly: optional.NewBool(true),
})
assert.Nil(t, err)
assert.Contains(t, email.Body, "Hello")

// list emails
emails, _, err := client.InboxControllerApi.GetInboxEmailsPaginated(ctx, inbox2.Id, nil)
assert.Nil(t, err)
assert.Equal(t, emails.TotalElements, int64(1))
```

--------------------------------

### Create Inbox

Source: https://www.mailslurp.com/docs/inboxes.md

Creates a new HTTP inbox with a randomly assigned email address. This is the simplest way to get started with an inbox.

```APIDOC
## Create Inbox

### Description
Creates a new HTTP inbox with a randomly assigned email address.

### Method
`POST`

### Endpoint
`/inboxes`

### Request Body
(Optional) Inbox creation options.

### Request Example
```typescript
const inbox = await mailslurp.createInbox();
// { id: '123', emailAddress: '123@mailslurp.com' }
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the inbox.
- **emailAddress** (string) - The email address of the inbox.

#### Response Example
```json
{
  "id": "123",
  "emailAddress": "123@mailslurp.com"
}
```
```

--------------------------------

### Example Extraction Prompt for Invoice Data

Source: https://www.mailslurp.com/docs/output-schemas.md

This prompt specifies the desired fields, their formats, and handling of missing values for extracting invoice records. It guides MailSlurp in generating an initial schema.

```text
Extract one invoice record from each attachment.

Return these fields:
- invoiceNumber: supplier invoice reference
- invoiceDate: YYYY-MM-DD string
- dueDate: YYYY-MM-DD string or null
- currency: one of USD, GBP, EUR
- supplier.name: company name
- totalAmount: numeric total
- lineItems: array of objects with description, quantity, unitPrice, and lineTotal

If a value is missing or ambiguous, return null rather than guessing.
```

--------------------------------

### Ruby SDK Example

Source: https://www.mailslurp.com/docs/overview.md

Illustrates using the Ruby SDK for inbox creation, email sending, and receiving. Configure the client with your API key and use the provided methods for email operations.

```ruby
# configure mailslurp client
MailSlurpClient.configure do |config|
  config.api_key['x-api-key'] = API_KEY
end

# create inboxes
inbox_controller = MailSlurpClient::InboxControllerApi.new
inbox_1 = inbox_controller.create_inbox
inbox_2 = inbox_controller.create_inbox

# send an email
inbox_controller.send_email(inbox_1.id,{
  to: [inbox_2.email_address],
  subject: 'Test',
  isHTML: true,
  body: '<h1>Hello!</h1>'
})

# receive email with wait controller
wait_controller = MailSlurpClient::WaitForControllerApi.new
email = wait_controller.wait_for_latest_email({ inbox_id: inbox_2.id, timeout: 60000 })
expect(email.body).to include("Hello")

# list inbox emails
emails = inbox_controller.get_emails(inbox_2.id)
expect(emails.length).to be(1)
```

--------------------------------

### Python SDK Example

Source: https://www.mailslurp.com/docs/overview.md

Shows how to use the Python SDK to create inboxes, send and receive emails, and assert email content. Requires the `mailslurp_client` library and an API key.

```python
import mailslurp_client
# create a mailslurp configuration
configuration = mailslurp_client.Configuration()
configuration.api_key['x-api-key'] = api_key
with mailslurp_client.ApiClient(configuration) as api_client:
    # create an inbox
    inbox_controller = mailslurp_client.InboxControllerApi(api_client)
    inbox_1 = inbox_controller.create_inbox()
    inbox_2 = inbox_controller.create_inbox()

    # send email
    opts = mailslurp_client.SendEmailOptions()
    opts.to = [inbox_2.email_address]
    opts.subject = "Hello"
    opts.body = "Email content <strong>supports HTML</strong>"
    opts.is_html = True
    inbox_controller.send_email(inbox_1.id, send_email_options=opts)

    # receive email with wait controller
    wait_controller = mailslurp_client.WaitForControllerApi(api_client)
    email = wait_controller.wait_for_latest_email(inbox_id=inbox_2.id, timeout=60000, unread_only=True)

    # assert that the message was received
    assert email.inbox_id == inbox_2.id
    assert email.subject == "Hello"
    assert "Email content" in email.body

    # list emails in inbox
    emails = inbox_controller.get_inbox_emails_paginated(inbox_2.id)
    assert len(emails.content) >= 1
```

--------------------------------

### Install PHP Extensions

Source: https://www.mailslurp.com/docs/php.md

Ensure these non-default PHP extensions are installed for the MailSlurp client to function correctly. These are typically included in most PHP installations.

```bash
php-ext-curl
php-xml
php-mbstring
```

```bash
sudo apt-get install php-ext-curl php-mbstring php-xml
```

--------------------------------

### Import MailSlurp Go Libraries

Source: https://www.mailslurp.com/docs/go.md

Import the necessary MailSlurp and context libraries for client initialization.

```go
import (
    "context"
    "github.com/mailslurp/mailslurp-client-go"
)
```

--------------------------------

### Demonstrate Paging Through Emails with Custom Page Size

Source: https://www.mailslurp.com/docs/pagination.md

Illustrates how to step through paginated results by specifying a custom page size. This example shows fetching the first three pages of emails, verifying the number of elements and whether each page is the last.

```typescript
// given an inbox with 7 emails
const count = await inboxController.getInboxEmailCount({
  inboxId: inbox.id
});
expect(count.totalElements).toEqual(7);

// paginate to demonstrate paging
const page1 = await emailController.getEmailsOffsetPaginated({
  page: 0, // 0-based index, 0 means first page
  size: 3,
  inboxId: [inbox.id]
});

// content and number of elements matching the page size
expect(page1.numberOfElements).toEqual(3);
expect(page1.content?.length).toEqual(3);
// is not last or empty
expect(page1.last).toEqual(false);
expect(page1.empty).toEqual(false);

// can page again to page 2
const page2 = await emailController.getEmailsOffsetPaginated({
  page: 1,
  size: 3,
  inboxId: [inbox.id]
});
// expect 3 inboxes again
expect(page2.numberOfElements).toEqual(3);
expect(page2.content?.length).toEqual(3);
// is not last or empty again
expect(page2.last).toEqual(false);
expect(page2.empty).toEqual(false);

// now get the last page
const page3 = await emailController.getEmailsOffsetPaginated({
  page: 2,
  size: 3,
  inboxId: [inbox.id]
});
// expect final inbox (7 - 3 - 3 = 1)
expect(page3.numberOfElements).toEqual(1);
expect(page3.content?.length).toEqual(1);
// is the last page (and not empty)
expect(page3.last).toEqual(true);
expect(page3.empty).toEqual(false);
```

--------------------------------

### Deliver Email using Curl with STARTTLS

Source: https://www.mailslurp.com/docs/imap-smtp.md

This example shows how to deliver an email using curl with STARTTLS encryption. The `--ssl-reqd` flag ensures a secure connection.

```bash
# Deliver email using curl with STARTTLS
curl -v --url "smtp://mailslurp.mx:2587" \
     --mail-from "$SENDER_EMAIL" \
     --mail-rcpt "$RECIPIENT_EMAIL" \
     --upload-file email.txt \ 
     --ssl-reqd
```

--------------------------------

### Install MailSlurp via Package Manager

Source: https://www.mailslurp.com/docs/csharp.md

Install the MailSlurp NuGet package using the Package Manager console.

```powershell
Install-Package mailslurp
```

--------------------------------

### Initialize MailSlurp Client

Source: https://www.mailslurp.com/docs/go.md

Configure and initialize the MailSlurp client using an API key and a background context. The API key should be securely managed.

```go
var apiKey = "your-mailslurp-client"

// create a context with your api key
ctx := context.WithValue(
    context.Background(),
    mailslurp.ContextAPIKey,
    mailslurp.APIKey{ Key: apiKey }
)

// create mailslurp client
config := mailslurp.NewConfiguration()
client := mailslurp.NewAPIClient(config)
```

--------------------------------

### Install cypress-mailslurp

Source: https://www.mailslurp.com/docs/cypress-mailslurp.md

Install the cypress-mailslurp package using npm. This is the first step to integrate MailSlurp into your Cypress tests.

```sh
npm install --save-dev cypress-mailslurp
```

--------------------------------

### Initialize MailSlurp SDK

Source: https://www.mailslurp.com/docs/device-renders.md

Set up the MailSlurp client using your API key. Read the API key from environment variables for local and CI execution.

```javascript
// Read the API key from the environment so examples can run locally and in CI.
const apiKey = process.env.MAILSLURP_API_KEY || process.env.API_KEY;

// Device render methods live on mailslurp.devicePreviewsController.
const mailslurp = new MailSlurp({ apiKey });
```

--------------------------------

### Install Certificate Fix for Windows

Source: https://www.mailslurp.com/docs/python.md

If you encounter certificate verification errors, install `python-certifi-win32`. This is often needed on Windows systems to resolve SSL/TLS issues.

```bash
pip install python-certifi-win32
```

--------------------------------

### Create Guest Portal and User

Source: https://www.mailslurp.com/docs/guest-portals.md

Use the GuestPortalController to create a new guest portal and add a user to it. The user's credentials and login URL are returned upon creation.

```typescript
const portal = await guestPortalController.createGuestPortal({
  createPortalOptions: {
    linkHelp: 'https://myschool.com/help/portal',
    description: 'Your school email portal',
    name: 'High School Email'
  }
});
const studentAccess = await guestPortalController.createGuestPortalUser({
  portalId: portal.id,
  createPortalOptions: {
    name: 'Jimmy'
  }
});
// user credentials are returned
log.info(studentAccess.password);
log.info(studentAccess.guest.loginUrl);
log.info(studentAccess.guest.username);
```

--------------------------------

### JavaScript MailSlurp SDK Example

Source: https://www.mailslurp.com/docs/overview.md

Set up the MailSlurp client, create inboxes, send an email, wait for the latest email, and list emails in JavaScript.

```javascript
// create mailslurp client
const { MailSlurp } = require('mailslurp-client');
const mailslurp = new MailSlurp({ apiKey: process.env.API_KEY });

// create inboxes
const inbox1 = await mailslurp.createInbox();
const inbox2 = await mailslurp.createInbox();

// send email
await mailslurp.sendEmail(inbox1.id, {
  to: [inbox2.emailAddress],
  subject: "Test",
  body: "<span>Hello 👋",
  isHTML: true
})

// receive email using wait methods
const email = await mailslurp.waitForLatestEmail(inbox2.id, 60000, true)
expect(email.body).toContain("Hello")

// list emails in inbox
const emails = await mailslurp.inboxController.getInboxEmailsPaginated({inboxId: inbox2.id})
expect(emails.numberOfElements).toEqual(1)
```

--------------------------------

### Install MailSlurp Client for Python

Source: https://www.mailslurp.com/docs/playwright.md

Install the MailSlurp client library for Python using pip. This is necessary for integrating MailSlurp with your Playwright Python tests.

```bash
pip install mailslurp-client
```

--------------------------------

### Cypress Test Email Sign Up Flow

Source: https://www.mailslurp.com/docs/cypress-mailslurp.md

This example demonstrates a full sign-up flow in Cypress using the MailSlurp plugin. It includes creating a temporary inbox, filling out a sign-up form, waiting for a verification email, extracting a code, and confirming the sign-up.

```typescript
it('can sign up using throwaway mailbox', function () {
    // create a mailslurp instance
    cy.mailslurp().then(function (mailslurp) {
        // visit the demo application
        cy.visit('/');
        // create an email address and store it on this
        cy.then(() => mailslurp.createInbox())
            .then((inbox) => {
                // save inbox id and email address to this
                cy.wrap(inbox.id).as('inboxId');
                cy.wrap(inbox.emailAddress).as('emailAddress');
            })
        // fill user details on app
        cy.get('[data-test=sign-in-create-account-link]').click()
        cy.then(function () {
            // access stored email on this, make sure you use Function and not () => {} syntax for correct scope
            cy.get('[name=email]').type(this.emailAddress)
            cy.get('[name=password]').type('test-password')
            return cy.get('[data-test=sign-up-create-account-button]').click();
        })
        // now wait for confirmation mail
        cy.then({ 
            // add timeout to the step to allow email to arrive
            timeout: 60_000
        }, function () {
            return mailslurp
                // wait for the email to arrive in the inbox
                .waitForLatestEmail(this.inboxId, 60_000, true)
                // extract the code with a pattern
                .then(email => mailslurp.emailController.getEmailContentMatch({
                    emailId: email.id,
                    contentMatchOptions: {
                        // regex pattern to extract verification code
                        pattern: 'Your Demo verification code is ([0-9]{6})'
                    }
                }))
                // save the verification code to this
                .then(({matches}) => cy.wrap(matches[1]).as('verificationCode'))
        });
        // confirm the user with the verification code
        cy.then(function () {
            cy.get('[name=code]').type(this.verificationCode)
            cy.get('[data-test=confirm-sign-up-confirm-button]').click()
            // use the email address and a test password
            cy.get('[data-test=username-input]').type(this.emailAddress)
            cy.get('[data-test=sign-in-password-input]').type('test-password')
            // click the submit button
            return cy.get('[data-test=sign-in-sign-in-button]').click();
        })
        cy.get('h1').should('contain', 'Welcome');
    });
});
```

--------------------------------

### Install MailSlurp Client for Node.js

Source: https://www.mailslurp.com/docs/playwright.md

Install the MailSlurp client library for Node.js using npm. This is the first step to using MailSlurp in your Playwright JavaScript tests.

```bash
npm install --save mailslurp-client
```

--------------------------------

### Email Content Match Request Example

Source: https://www.mailslurp.com/docs/browserstack

This is an example of the JSON request body for matching content within an email. The 'pattern' field should contain a Java-style regex.

```JSON
{
  "pattern": "value"
}
```

--------------------------------

### C# MailSlurp SDK Example

Source: https://www.mailslurp.com/docs/overview.md

Initialize the MailSlurp client, create inboxes, send an email, wait for the latest email, and list emails in C#.

```csharp
// create client
var config = new Configuration();
config.ApiKey.Add("x-api-key", ApiKey);

// create inboxes
var inboxControllerApi = new InboxControllerApi(config);
var inbox1 = inboxControllerApi.CreateInbox();
var inbox2 = inboxControllerApi.CreateInbox();

// send email
inboxControllerApi.SendEmail(inbox1.Id, new SendEmailOptions(
    to: new List<string> { inbox2.EmailAddress },
    subject: "Test CSharp",
    body: "<span>Hello",
    isHTML: true
));

// receive email with wait controller
var email = new WaitForControllerApi(config).WaitForLatestEmail(inbox2.Id, 60000, true);
StringAssert.Contains(email.Body, "Hello");

// list emails in inbox
var emails = inboxControllerApi.GetInboxEmailsPaginated(inbox2.Id);
Assert.AreEqual(emails.TotalElements, 1);
```

--------------------------------

### Java MailSlurp SDK Example

Source: https://www.mailslurp.com/docs/overview.md

Configure the MailSlurp client, create inboxes, send an email, wait for the latest email, and list emails in Java.

```java
// create client
ApiClient client = Configuration.getDefaultApiClient();
client.setApiKey(apiKey);
client.setHttpClient(httpClient);

// create inboxes
InboxControllerApi inboxControllerApi = new InboxControllerApi(client);
InboxDto inbox1 = inboxControllerApi.createInboxWithDefaults().execute();
InboxDto inbox2 = inboxControllerApi.createInboxWithDefaults().execute();

// send email
SendEmailOptions sendOptions = new SendEmailOptions();
sendOptions.setTo(Collections.singletonList(inbox2.getEmailAddress()));
sendOptions.setSubject("Test");
sendOptions.setBody("<span>Hello");
sendOptions.setIsHTML(true);
inboxControllerApi.sendEmail(inbox1.getId(), sendOptions);

// receive email with wait for controller
Email email = new WaitForControllerApi(client).waitForLatestEmail().inboxId(inbox2.getId()).timeout(60000L).unreadOnly(true).execute();
assertEquals(email.getBody().contains("Hello"), true);

// list emails in inbox
PageEmailPreview emails = inboxControllerApi.getInboxEmailsPaginated(inbox2.getId()).execute();
```

--------------------------------

### Configure an SMTP client for sending emails

Source: https://www.mailslurp.com/docs/csharp.md

Set up an `SmtpClient` using the IMAP/SMTP access details obtained previously. Ensure `EnableSsl` is set to `true` for secure connections.

```csharp
var smtpClient = new SmtpClient(imapSmtpAccess.SecureSmtpServerHost)
{
    Port = imapSmtpAccess.SecureSmtpServerPort,
    Credentials = new NetworkCredential(userName: imapSmtpAccess.SecureSmtpUsername,
        password: imapSmtpAccess.SecureSmtpPassword),
    EnableSsl = true
};
// smtpClient.Send(...);
```

--------------------------------

### Create Inbox with API Key and Handle Response

Source: https://www.mailslurp.com/docs/swift.md

This example shows how to create an inbox using the Swift client, including API key authentication and handling the response using PromiseKit. It also includes basic error handling.

```swift
let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? ""
InboxControllerAPI.createInboxWithDefaultsWithRequestBuilder()
    // use addHeader to add your api key to requests
    .addHeader(name: "x-api-key", value: apiKey)
    .execute()
    // uses PromiseKit for response handling
    .done { response in
        XCTAssertTrue(response.body?.emailAddress?.contains("@mailslurp") ?? false)
        XCTAssertTrue(response.statusCode == 201)
        expectation.fulfill()
    }.catch { errorType in 
        // handle error, cast to mailslurp.ErrorResponse using guard to access .error(statusCode, data, _, _)
    }
```

--------------------------------

### Get or Create Plus Address by Full Address

Source: https://www.mailslurp.com/docs/plus-addresses.md

Use this cURL command to get or create a plus address entity by providing the full email address. This is useful for deterministic retrieval and avoids broad inbox searches.

```bash
BASE_URL="https://api.mailslurp.com"
API_KEY="REPLACE_WITH_API_KEY"
FULL_PLUS_ADDRESS="app-user+signup-9f3a@example.test"

curl -sS -X POST \
  -G "$BASE_URL/inboxes/get-or-create-plus-address" \
  --data-urlencode "fullAddress=$FULL_PLUS_ADDRESS" \
  -H "x-api-key: $API_KEY" \
  -H "accept: application/json"
```

--------------------------------

### Upload Attachment and Send Email with Attachment

Source: https://www.mailslurp.com/docs/go.md

Uploads an attachment and sends an email with the attachment included. It then waits for the email to arrive and downloads the attachment.

```go
func uploadAttachment(t *testing.T) []string {
    client, ctx := createClient(t)
    attachmentBytes := []byte{0}
    uploadOpts := mailslurp.UploadAttachmentOptions{
        Base64Contents: base64.URLEncoding.EncodeToString(attachmentBytes),
        ContentType:    "text/plain",
        Filename:       "test.txt",
    }
    attachmentIds, _, err := client.AttachmentControllerApi.UploadAttachment(ctx, uploadOpts)
    assert.Nil(t, err)
    return attachmentIds
}

func Test_CanSendEmail_AndReceive(t *testing.T) {
    client, ctx := createClient(t)
    opts := &mailslurp.CreateInboxOpts{}

    // create two inboxes
    inbox1, _, err := client.InboxControllerApi.CreateInbox(ctx, opts)
    inbox2, _, err := client.InboxControllerApi.CreateInbox(ctx, opts)

    assert.Nil(t, err)

    // upload attachments before send
    attachmentIds := uploadAttachment(t)

    // send a simple email from inbox 1 to inbox 2
    sendOpts := &mailslurp.SendEmailOpts{
        SendEmailOptions: optional.NewInterface(mailslurp.SendEmailOptions{
            To:      []string{inbox2.EmailAddress},
            Subject: "Test subject",
            Body:    "Hello from inbox 1",
            Attachments: attachmentIds,
        }),
    }

    _, err = client.InboxControllerApi.SendEmail(ctx, inbox1.Id, sendOpts)
    assert.Nil(t, err)

    // now receive the email at inbox 2
    waitForOpts := &mailslurp.WaitForLatestEmailOpts{
        InboxId:    optional.NewInterface(inbox2.Id),
        Timeout:    optional.NewInt64(30000),
        UnreadOnly: optional.NewBool(true),
    }
    email, _, err := client.WaitForControllerApi.WaitForLatestEmail(ctx,waitForOpts)
    assert.Nil(t, err)

    // access content
    assert.Equal(t, email.InboxId, inbox2.Id)
    assert.Contains(t, email.Subject, "Test subject")
    assert.Contains(t, email.Body, "Hello from inbox 1")

    // download the attachment as bytes
    downloadedBytes, _, err := client.EmailControllerApi.DownloadAttachment(ctx, email.Attachments[0], email.Id, nil)
    assert.Nil(t, err)
    assert.NotEmpty(t, downloadedBytes)
}
```

--------------------------------

### Get SMS Message

Source: https://www.mailslurp.com/docs/txt-sms.md

Retrieves a single SMS message by its unique ID.

```APIDOC
## GET /sms/{smsId}

### Description
Fetches a specific SMS message by its ID.

### Method
GET

### Endpoint
/sms/{smsId}

### Parameters
#### Path Parameters
- **smsId** (string) - Required - The UUID of the SMS message to retrieve.

### Response
#### Success Response (200)
- **read** (boolean) - Indicates if the message has been read.
- **fromNumber** (string) - The sender's phone number.

### Request Example
```javascript
const txtMessage = await mailslurp.smsController.getSmsMessage({
  smsId: sms.id
});
```

### Response Example
```json
{
  "read": true,
  "fromNumber": "+13252527014"
}
```
```

--------------------------------

### Send and Receive Email in Kotlin

Source: https://www.mailslurp.com/docs/kotlin.md

Shows how to send an email to a newly created inbox and then wait to receive it. Verifies the subject of the received email.

```kotlin
package com.mailslurp.examples

import com.mailslurp.apis.InboxControllerApi
import com.mailslurp.apis.WaitForControllerApi
import com.mailslurp.models.SendEmailOptions
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
import kotlin.test.assertEquals
import kotlin.test.assertTrue

@RunWith(JUnit4::class)
class MailSlurpKotlinTest {

  private val apiKey: String by lazy { System.getenv("API_KEY") }

  @Test
  fun `can send and receive email`() {
    // create inbox
    val inboxController = InboxControllerApi(apiKey)
    val waitForController = WaitForControllerApi(apiKey)
    val inbox = inboxController.createInbox(null, null, null, null, null, null, null, null, null)

    val testSubject = "test-subject"
    val confirmation = inboxController.sendEmailAndConfirm(
      inboxId = inbox.id!!,
      sendEmailOptions = SendEmailOptions(
        to = listOf(inbox.emailAddress!!),
        subject = testSubject
      )
    )
    assertEquals(confirmation.inboxId, inbox.id)

    val email = waitForController.waitForLatestEmail(
      inboxId = inbox.id!!,
      timeout = 60_000,
      unreadOnly = true
    )
    assertTrue(email.subject == "test-subject")
  }
```

--------------------------------

### Get Inbox by ID

Source: https://www.mailslurp.com/docs/inboxes.md

Retrieves a specific inbox using its unique ID.

```APIDOC
## GET /inboxes/{inboxId}

### Description
Fetches a specific inbox by its ID.

### Method
GET

### Endpoint
/inboxes/{inboxId}

### Parameters
#### Path Parameters
- **inboxId** (string) - Required - The ID of the inbox to retrieve.

### Response
#### Success Response (200)
- **id** (string) - The unique identifier of the inbox.
- **emailAddress** (string) - The email address of the inbox.
- **name** (string) - The name of the inbox.
- **createdAt** (string) - The date and time the inbox was created.

### Request Example
```
GET /inboxes/inbox_id_123
```

### Response Example
```json
{
  "id": "inbox_id_123",
  "emailAddress": "user@example.com",
  "name": "My Test Inbox",
  "createdAt": "2023-01-01T12:00:00.000Z"
}
```
```

--------------------------------

### Get SMS Codes

Source: https://www.mailslurp.com/docs/txt-sms.md

Retrieves SMS codes, useful for testing and verification purposes.

```APIDOC
## GET /sms/codes

### Description
Fetches SMS codes. This endpoint is useful for tests that need to extract verification codes from received SMS messages.

### Method
GET

### Endpoint
/sms/codes

### Response
#### Success Response (200)
- **code** (string) - The extracted SMS code.

### Request Example
```javascript
// Example usage for extracting codes would typically involve filtering or specific parameters not detailed here.
// This is a placeholder based on the mention of 'getSmsCodes'.
const smsCodes = await mailslurp.smsController.getSmsCodes();
```
```

--------------------------------

### Create Inbox with Options

Source: https://www.mailslurp.com/docs/rust.md

Demonstrates creating a new MailSlurp inbox with specific parameters like enabling domain pool access. Methods are asynchronous and return results.

```rust
fn use_controllers() {
    // create an inbox
    let create_inbox_params = inbox_controller_api::CreateInboxParams{
        allow_team_access: None,
        description: None,
        email_address: None,
        expires_at: None,
        expires_in: None,
        favourite: None,
        name: None,
        tags: None,
        use_domain_pool: Some(true)
    };
    // methods are async and return results
    let inbox = inbox_controller_api::create_inbox(&configuration, create_inbox_params).await.ok().unwrap();
    // entity fields are options but see rest api docs for what will be set
    assert!(inbox.email_address.unwrap().contains("@mailslurp"));
}
```

--------------------------------

### Get Phone Number By Name

Source: https://www.mailslurp.com/docs/txt-sms.md

Retrieves a specific phone number by its assigned name.

```APIDOC
## GET /phoneNumbers/name/{name}

### Description
Fetches a phone number by its given name.

### Method
GET

### Endpoint
/phoneNumbers/name/{name}

### Parameters
#### Path Parameters
- **name** (string) - Required - The name of the phone number to retrieve.

### Response
#### Success Response (200)
- **phoneNumber** (string) - The phone number string.

### Request Example
```javascript
const phoneBy = await mailslurp.phoneController.getPhoneNumberByName({
  name: 'Sales inbound'
});
```
```

--------------------------------

### Configure MailSlurp API Key

Source: https://www.mailslurp.com/docs/python.md

Set up the MailSlurp client configuration by importing the library and assigning your API key. Replace YOUR_API_KEY with your actual MailSlurp API key.

```python
import mailslurp_client

configuration = mailslurp_client.Configuration()
configuration.api_key["x-api-key"] = YOUR_API_KEY
```

--------------------------------

### Get Email Links

Source: https://www.mailslurp.com/docs/emails.md

Extract all links present within the body of a specific email.

```APIDOC
## GET /emails/{emailId}/links

### Description
Extracts and returns a list of all URLs found within the body of a specified email.

### Method
GET

### Endpoint
/emails/{emailId}/links

### Parameters
#### Path Parameters
- **emailId** (string) - Required - The ID of the email to extract links from.

### Response
#### Success Response (200)
- **links** (array) - A list of extracted URLs.

### Response Example
{
  "links": [
    "http://example.com/page1",
    "http://example.com/page2"
  ]
}
```

--------------------------------

### CodeceptJS Test Scenario for User Sign Up

Source: https://www.mailslurp.com/docs/codeceptjs.md

An example test scenario demonstrating user sign-up with email verification using MailSlurp. This test creates a new mailbox, fills out a sign-up form, waits for a confirmation email, extracts the verification code, and submits it to complete the sign-up process.

```javascript
Scenario('Test user sign up',  async ({ I }) => {
    // create a dummy inbox with MailSlurp
    const emailAccount = await I.haveNewMailbox()
    const password = 'test-password';

    // load application
    I.amOnPage(MY_APPLICATION);

    // fill signup form
    I.click('[data-test="sign-in-create-account-link"]')
    I.fillField('[name="email"]', emailAccount.emailAddress);
    I.fillField('[name="password"]', password);
    I.click('[data-test="sign-up-create-account-button"]');

    // wait for confirmation email
    const email = await I.waitForEmailMatching({
        subject: "Please confirm your email address"
    })
    // extract content use regex pattern
    const [_, code] = /verification code is (\d+)/.exec(email.body)

    // submit verification code
    I.fillField('[name="code"]', code)
    I.click('[data-test="confirm-sign-up-confirm-button"]');

    // now login with verified account
    I.fillField('[name="username"]', emailAccount.emailAddress);
    I.fillField('[name="password"]', password);
    I.click('[data-test="sign-in-sign-in-button"]');

    // see welcome message
    I.waitForElement('img[src*="welcome"]', 30);
});
```

--------------------------------

### Install MailSlurp with Rebar.config

Source: https://www.mailslurp.com/docs/elixir.md

Specify the MailSlurp dependency version in your `rebar.config` file for Erlang projects.

```text
{mailslurp, "11.6.0"}
```
Tokens:
Raw