IMAP SMTP inbox access

Bash

# download access details for an inbox as .env file and source
curl -o .env -sXGET "https://api.mailslurp.com/inboxes/imap-smtp-access/env?inboxId=$INBOX_ID" -H"x-api-key:$API_KEY"
# source the .env and connect using variables
source .env

Powershell

# download access details for an inbox as .env file
Set-Location $PSScriptRoot
Invoke-WebRequest -OutFile ".env" -Uri "https://api.mailslurp.com/inboxes/imap-smtp-access/env?inboxId=$inboxId" -Headers @{"x-api-key" = $API_KEY}

# source the .env and connect using variables
Get-Content ".env" | ForEach-Object {
    $keyValue = $_.Split('=', 2)
    if ($keyValue.Count -eq 2)
    {
        $envName = $keyValue[0].Trim()
        $envValue = $keyValue[1].Trim()
        # Remove leading and trailing double quotes from the value
        if ($envValue.StartsWith('"') -and $envValue.EndsWith('"'))
        {
            $envValue = $envValue.Substring(1, $envValue.Length - 2)
        }
        [Environment]::SetEnvironmentVariable($envName, $envValue, [System.EnvironmentVariableTarget]::Process)
    }
}

Insecure

curl "imap://$IMAP_SERVER_HOST:$IMAP_SERVER_PORT/INBOX" -vu "$IMAP_USERNAME:$IMAP_PASSWORD"

Secure

curl --ssl "imaps://$SECURE_IMAP_SERVER_HOST:$SECURE_IMAP_SERVER_PORT/INBOX" -vu "$SECURE_IMAP_USERNAME:$SECURE_IMAP_PASSWORD"

Javascript

const server = await mailslurp.inboxController.getImapAccess({});
const client = new ImapFlow({
  host: server.imapServerHost,
  port: server.imapServerPort,
  secure: false,
  auth: {
    user: server.imapUsername,
    pass: server.imapPassword
  }
});

Insecure

(echo "HELO test.client"; echo "QUIT") | nc "$SMTP_SERVER_HOST" "$SMTP_SERVER_PORT"

Secure

echo -e "HELO test.client\nQUIT\n" | openssl s_client -connect $SMTP_SERVER_HOST:$SMTP_SERVER_PORT -starttls smtp -quiet

Insecure

const transportInsecure = nodemailer.createTransport({
    host: smtpServerHost,
    port: smtpServerPort,
    secure: false,
    auth: {
        user: smtpUsername,
        pass: smtpPassword,
        type: 'PLAIN',
    },
});
await transportInsecure.sendMail({
    from: 'test@mailslurp.dev',
    to: inbox.emailAddress,
    subject: "Test insecure",
})

Secure

const transportSecure = nodemailer.createTransport({
    host: "mailslurp.mx",
    port: 465,
    secure: true,
    tls: {
        rejectUnauthorized: false,
        ciphers: 'SSLv3'
    },
    auth: {
        user: secureSmtpUsername,
        pass: secureSmtpPassword,
        type: 'PLAIN',
    },
});
await transportSecure.sendMail({
    from: 'test@mailslurp.dev',
    to: inbox.emailAddress,
    subject: "Test secure",
    attachments: [
        {
            filename: "example.txt",
            content: Buffer.from('hello world!', 'utf-8')
        }
    ],
})

Curl

# Email content
cat <>email.txt
From: Jack <$SENDER_EMAIL>
To: Joe <$RECIPIENT_EMAIL>
Subject: SMTP example
Date: Mon, 7 Nov 2016 03:45:06

Dear Joe,
How splendid life is.
EOF
# Send email using curl
curl -v --url "smtp://mxslurp.click:2525" \
     --user "$SMTP_USERNAME:$SMTP_PASSWORD" \
     --mail-from "$SENDER_EMAIL" \
     --mail-rcpt "$RECIPIENT_EMAIL" \
     --upload-file email.txt

Curl

# Deliver email using curl insecure
curl -v --url "smtp://mxslurp.click:2525" \
     --mail-from "$SENDER_EMAIL" \
     --mail-rcpt "$RECIPIENT_EMAIL" \
     --upload-file email.txt \

STARTTLS

# 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

SMTPS

# Deliver email using curl with SMTPS
curl -v --url "smtps://mailslurp.mx:465" \
     --mail-from "$SENDER_EMAIL" \
     --mail-rcpt "$RECIPIENT_EMAIL" \
     --upload-file email.txt \

SMTPS+SSL

# Deliver email using curl with SMTPS encrypted
curl -v --url "smtps://mailslurp.mx:465" \
     --mail-from "$SENDER_EMAIL" \
     --mail-rcpt "$RECIPIENT_EMAIL" \
     --upload-file email.txt \
     --ssl-reqd

Javascript

describe("testing smtp", function () {
    it("can create an mailbox and get email preview urls", async function () {
        const apiKey = process.env.API_KEY;
        if (!apiKey) {
            throw new Error("Please set API_KEY environment variable")
        }
        const mailslurp = new MailSlurp({apiKey, fetchApi})
        const access = await mailslurp.getImapSmtpAccessDetails();
        expect(access).toBeTruthy();

        const inbox1 = await mailslurp.createInboxWithOptions({inboxType: 'SMTP_INBOX'})
        const inbox2 = await mailslurp.createInboxWithOptions({inboxType: 'SMTP_INBOX'})

        const transporter = nodemailer.createTransport({
            host: access.smtpServerHost,
            port: access.smtpServerPort,
            secure: false,
            auth: {
                user: access.smtpUsername,
                pass: access.smtpPassword
            },
        });

        const sent = await transporter.sendMail({
            from: inbox1.emailAddress,
            to: inbox2.emailAddress,
            subject: "From inbox 1 to inbox 2",
            text: "Hi there",
            attachments: [
                {
                    filename: "example.txt",
                    content: Buffer.from('hello world!', 'utf-8')
                }
            ],
        });
        expect(sent).toBeTruthy()

        const email = await mailslurp.waitForLatestEmail(inbox2.id, 30_000, true);
        expect(email.subject).toEqual("From inbox 1 to inbox 2")
        expect(email.attachments.length).toEqual(1)
        const accessUrls = await mailslurp.emailController.getEmailPreviewURLs({emailId: email.id})

        // access these urls in browser to view email content
        expect(accessUrls.plainHtmlBodyUrl).toContain("https://api.mailslurp.com")
        expect(accessUrls.rawSmtpMessageUrl).toContain("https://api.mailslurp.com")
    });
});

Java

@Test
public void canSendWithSmtp() throws MessagingException, ApiException {
    CreateInboxDto opts = new CreateInboxDto();
    opts.setInboxType(CreateInboxDto.InboxTypeEnum.SMTP_INBOX);
    InboxControllerApi inboxControllerApi = new InboxControllerApi(apiClient);
    InboxDto inbox = inboxControllerApi.createInboxWithOptions(opts).execute();

    ImapSmtpAccessDetails server = inboxControllerApi.getImapSmtpAccess().inboxId(inbox.getId()).execute();

    Properties prop = new Properties();
    prop.put("mail.smtp.auth", "true");
    prop.put("mail.transport.protocol", "smtp");
    prop.put("mail.smtp.starttls.enable", "false");
    prop.put("mail.smtp.host", server.getSmtpServerHost());
    prop.put("mail.smtp.port", server.getSmtpServerPort());


    class SMTPAuthenticator extends javax.mail.Authenticator {
        public PasswordAuthentication getPasswordAuthentication() {
            String username = server.getSmtpUsername();
            String password = server.getSmtpPassword();
            return new PasswordAuthentication(username, password);
        }
    }

    Authenticator auth = new SMTPAuthenticator();
    Session mailSession = Session.getDefaultInstance(prop, auth);
    mailSession.setDebug(true);

    Message message = new MimeMessage(mailSession);
    message.setFrom(new InternetAddress(inbox.getEmailAddress()));
    message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(inbox.getEmailAddress()));
    message.setSubject("Test subject");

    String msg = "This is my first email";

    MimeBodyPart mimeBodyPart = new MimeBodyPart();
    mimeBodyPart.setContent(msg, "text/html; charset=utf-8");

    Multipart multipart = new MimeMultipart();
    multipart.addBodyPart(mimeBodyPart);

    message.setContent(multipart);

    Transport.send(message);
}

PHP

// create inbox
$create = new \MailSlurp\Models\CreateInboxDto(["inbox_type"=>"SMTP_INBOX"]);
$inbox = $inboxController->createInboxWithOptions($create);
$this->assertTrue($inbox->getInboxType() == "SMTP_INBOX");
// create smtp
$server = $inboxController->getImapSmtpAccess();
$mail = new PHPMailer(true);
try {
    $mail->SMTPDebug = SMTP::DEBUG_SERVER;
    $mail->isSMTP();
    $mail->Host = $server->getSmtpServerHost();
    $mail->Port = $server->getSmtpServerPort();
    $mail->SMTPAutoTLS = false;
    $mail->SMTPAuth = false;
    $mail->setFrom("test@gmail.com", 'Test1');
    $mail->addAddress($inbox->getEmailAddress(), 'Test2');
    $mail->isHTML(true);
    $mail->Subject = 'Test subject';
    $mail->Body = 'This is test HTML body <b>in bold!</b>';
    $mail->addAttachment($this->pathToAttachment2);
    // now connect and send
    $mail->send();
    echo 'Message has been sent';
} catch (Exception $e) {
    echo "Message could not be sent. Mailer Error: {$mail->ErrorInfo}";
}
if ($mail->ErrorInfo) {
    echo $mail->ErrorInfo;
}
$this->assertTrue($mail->ErrorInfo == '');

Python

with mailslurp_client.ApiClient(configuration) as api_client:
    inbox_controller = mailslurp_client.InboxControllerApi(api_client)
    inbox1 = inbox_controller.create_inbox_with_options(CreateInboxDto(inbox_type="SMTP_INBOX"))
    inbox2 = inbox_controller.create_inbox()
    assert "@mailslurp" in inbox1.email_address

    # get smtp imap access
    smtp_access = inbox_controller.get_imap_smtp_access(inbox_id=inbox1.id)
    msg = "Subject: Test subject\r\n\r\nThis is the body"

    with SMTP(host=smtp_access.smtp_server_host, port=smtp_access.smtp_server_port) as smtp:
        smtp.login(user=smtp_access.smtp_username, password=smtp_access.smtp_password)
        smtp.sendmail(from_addr=inbox1.email_address, to_addrs=[inbox2.email_address], msg=msg)
        smtp.quit()

    wait_for_controller = mailslurp_client.WaitForControllerApi(api_client)
    email = wait_for_controller.wait_for_latest_email(inbox_id=inbox2.id)
    assert "Test subject" in email.subject

Ruby

inbox_controller = MailSlurpClient::InboxControllerApi.new

# create two inboxes
inbox1 = inbox_controller.create_inbox_with_options({ inboxType: 'SMTP_INBOX' })
inbox2 = inbox_controller.create_inbox

expect(inbox1.email_address).to include('@mailslurp.mx')

# get smtp access for inbox
smtp_access = inbox_controller.get_imap_smtp_access({ inbox_id: inbox1.id })

# compose email
message = <<~MESSAGE_END
  From: #{inbox1.email_address}
  To: #{inbox2.email_address}
  Subject: Test smtp email

  This is a test
MESSAGE_END

Net::SMTP.start(smtp_access.smtp_server_host, smtp_access.smtp_server_port, 'greeting.your.domain',
                smtp_access.smtp_username, smtp_access.smtp_password, :plain) do |smtp|
  # send email
  smtp.send_message message, inbox1.email_address, inbox2.email_address
end