PostRabbit Transactional Email API Documentation

This document details all API endpoints for sending, retrieving, and managing transactional emails.

Base URL

https://api.postrabbit.com

All endpoints below are relative to this base URL.

Authentication

This API uses a Basic Authorization header with an API key token.

The API key is sent by itself (no username or password)
The API key is Base64-encoded

Header Format:

Authorization: Basic <base64(API_KEY)>

Example (Linux/Mac)

echo -n "YOUR_API_KEY" | base64

Header sent:

Authorization: Basic MTIzNDU2Nzg5IQ==

Example (C# .NET 4.7.2):


    string apiKey = "YOURAPIKEY";

    // Base64 encode the API key ONLY
    string authValue = Convert.ToBase64String(
    Encoding.ASCII.GetBytes(apiKey));

    client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Basic", authValue);

1. Send Message — multipart/form-data

POST /v1/messages

Send a transactional email using individual form fields.

Headers

Authorization - Basic Authentication.  Encode only your API key.

Content-Type:

multipart/form-data

Parameters

Field	Required	Description
from	Yes	Email address of sender
to	Yes	Email(s) of recipient(s), comma-separated
subject	Yes	Email subject
HtmlView	Yes*	HTML body (or provide TextView)
TextView	Optional	Text-only body
CcAddress	Optional	CC email addresses
BccAddress	Optional	BCC email addresses
SendAfterDateTime	Optional	RFC-2822 schedule time in UTC timezone (defaults to UtcNow)
Tracking	Optional	true / false / yes / no
SuppressHeaders	Optional	true / false / yes / no
Headers	Optional	Custom Headers
Attachments	Optional	Send attachments using fields named attachmentX

Response (JSON)

{
    "status": "ok",
    "EmailID": "generated-message-id"
}

Code Examples

cURL Example


    curl -X POST "https://api.postrabbit.com/v1/messages" \
    -H "Authorization: Basic BASE64ENCODEDKEY" \
    -F "from=from@email.com" \
    -F "to=to@email.com" \
    -F "subject=PostRabbit Email is Easy" \
    -F "HtmlView=<b>Hello World</b>" \
    -F "TextView=This is a text email" \
    -F "SendAfterDateTime=Tue, 11 Feb 2026 15:00:00 +0000" \
    -F "Tracking=true" \
    -F "CcAddress=cc@email.com" \
    -F "SuppressHeaders=true" \
    -F "Headers=X-Report-Abuse:Please report abuse for this email to: email@email.com" \
    -F "Headers=List-Unsubscribe:<https://www.website.com/emailoptout.aspx?email=email@email.com>, <mailto:bounce@website.com?subject=unsubscribeemail@email.com>" \
    -F "BccAddress=1@email.com,2@email.com" \ 
    -F "attachment1=/path/to/file1.jpg" \
    -F "attachment2=/path/to/file2.pdf"

JavaScript (Browser fetch)



   
const apiUrl = "https://api.postrabbit.com/v1/messages";

// Your API key (NOT username:password, just the key)
const apiKey = "YOURAPIKEY";

// Base64 encode exactly what your API expects
const authValue = btoa(apiKey);

const form = new FormData();

// ---- Required fields ----
form.append("from", "from@email.com");
form.append("to", "to@email.com");
form.append("subject", "PostRabbit Email is Easy");

// --- At least one of the two fields needs to be set ---
form.append("HtmlView", "<b>Hello World</b>");
form.append("TextView", "This is a text email");

// --- Optional Fields ---
const sendAfter = new Date(Date.now() + 24 * 60 * 60 * 1000)
    .toUTCString();

form.append("SendAfterDateTime", sendAfter);
form.append("Tracking", "true");
form.append("CcAddress", "cc@email.com");

// Suppress default headers
form.append("SuppressHeaders", "true");

// Add custom headers (repeatable field)
form.append("Headers", "X-Report-Abuse:Please report abuse for this email to: email@email.com");
form.append("Headers", "List-Unsubscribe:<https://www.website.com/emailoptout.aspx?email=email@email.com>, <mailto:bounce@website.com?subject=unsubscribeemail@email.com>");

// BCC
form.append("BccAddress", "1@email.com,2@email.com");

fetch(apiUrl, {
    method: "POST",
    headers: {
        "Authorization": `Basic ${authValue}`
    },
    body: form
})
.then(response => response.text())
.then(data => {
    console.log("Response:", data);
})
.catch(error => {
    console.error("Error:", error);
});

Node.js (axios)


 
import fs from "fs";
import axios from "axios";
import FormData from "form-data";

const apiUrl = "https://api.postrabbit.com/v1/messages";

// Your API key (NOT username:password, just the key)
const apiKey = "YOURAPIKEY";

// Base64 encode exactly what your API expects
const authValue = Buffer.from(apiKey, "ascii").toString("base64");

const form = new FormData();

// ---- Required fields ----
form.append("from", "from@email.com");
form.append("to", "to@email.com");
form.append("subject", "PostRabbit Email is Easy");

// --- At least one of the two fields needs to be set ---
form.append("HtmlView", "<b>Hello World</b>");
form.append("TextView", "This is a text email");

// --- Optional Fields ---
const sendAfter = new Date(Date.now() + 24 * 60 * 60 * 1000).toUTCString();

form.append("SendAfterDateTime", sendAfter);
form.append("Tracking", "true");
form.append("CcAddress", "cc@email.com");

// Suppress default headers
form.append("SuppressHeaders", "true");

// Add custom headers (repeatable field)
form.append("Headers", "X-Report-Abuse:Please report abuse for this email to: email@email.com");
form.append("Headers", "List-Unsubscribe:<https://www.website.com/emailoptout.aspx?email=email@email.com>, <mailto:bounce@website.com?subject=unsubscribeemail@email.com>");

// BCC
const bccAddresses = ["1@email.com", "2@email.com"];
form.append("BccAddress", bccAddresses.join(","));

// Attachments
form.append("attachment1", fs.createReadStream("FILEPATH"));
form.append("attachment1", fs.createReadStream("FILEPATH2"));

// Send the request with Axios
axios.post(apiUrl, form, {
    headers: {
        "Authorization": `Basic ${authValue}`,
        ...form.getHeaders() // necessary for multipart/form-data
    }
})
.then(response => {
    console.log("Status:", response.status);
    console.log("Response:", response.data);
})
.catch(error => {
    console.error("Error:", error.response ? error.response.data : error.message);
});

Python (requests)


    import base64
    import requests
    from datetime import datetime, timedelta

    api_url = "https://api.postrabbit.com/v1/messages"

    # Your API key (NOT username:password, just the key)
    api_key = "YOURAPIKEY"

    # Base64 encode exactly what your API expects
    auth_value = base64.b64encode(api_key.encode("ascii")).decode("ascii")

    headers = {
    "Authorization": f"Basic {auth_value}"
    }

    # ---- Required fields ----
    data = {
    "from": "from@email.com",
    "to": "to@email.com",
    "subject": "PostRabbit Email is Easy",
    "HtmlView": "<b>Hello World</b>",
    "TextView": "This is a text email",
    "SendAfterDateTime": (datetime.utcnow() + timedelta(days=1)).strftime("%a, %d %b %Y %H:%M:%S +0000"),
    "Tracking": "true",
    "CcAddress": "cc@email.com",
    "SuppressHeaders": "true",
    "Headers": "X-Report-Abuse:Please report abuse for this email to: email@email.com",
    # Repeatable Headers field for List-Unsubscribe
    "Headers": "List-Unsubscribe:<https://www.website.com/emailoptout.aspx?email=email@email.com>, <mailto:bounce@website.com?subject=unsubscribeemail@email.com>",
    "BccAddress": "1@email.com,2@email.com"
    }

    # --- Optional Attachments ---
    files = {
    "attachment1": open("FILEPATH", "rb"),
    "attachment1": open("FILEPATH2", "rb")
    }

    response = requests.post(api_url, headers=headers, data=data, files=files)

    print("Status:", response.status_code)
    print("Response:", response.text)

Java (OkHttp)


    import okhttp3.*;
    import java.io.File;
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    import java.util.Base64;

    public class PostRabbitOkHttpExample {
    public static void main(String[] args) throws IOException {
    String apiUrl = "https://api.postrabbit.com/v1/messages";
    String apiKey = "YOURAPIKEY";

    // Base64 encode API key
    String authValue = Base64.getEncoder().encodeToString(apiKey.getBytes(StandardCharsets.US_ASCII));

    OkHttpClient client = new OkHttpClient();

    // Build multipart form
    MultipartBody.Builder builder = new MultipartBody.Builder()
    .setType(MultipartBody.FORM);

    // ---- Required fields ----
    builder.addFormDataPart("from", "from@email.com");
    builder.addFormDataPart("to", "to@email.com");
    builder.addFormDataPart("subject", "PostRabbit Email is Easy");

    // --- At least one of the two fields needs to be set ---
    builder.addFormDataPart("HtmlView", "<b>Hello World</b>");
    builder.addFormDataPart("TextView", "This is a text email");

    // --- Optional Fields ---
    String sendAfter = java.time.ZonedDateTime.now().plusDays(1)
    .format(java.time.format.DateTimeFormatter.RFC_1123_DATE_TIME);
    builder.addFormDataPart("SendAfterDateTime", sendAfter);
    builder.addFormDataPart("Tracking", "true");
    builder.addFormDataPart("CcAddress", "cc@email.com");
    builder.addFormDataPart("SuppressHeaders", "true");

    // Custom headers
    builder.addFormDataPart("Headers", "X-Report-Abuse:Please report abuse for this email to: email@email.com");
    builder.addFormDataPart("Headers", "List-Unsubscribe:<https://www.website.com/emailoptout.aspx?email=email@email.com>, <mailto:bounce@website.com?subject=unsubscribeemail@email.com>");

    // BCC
    builder.addFormDataPart("BccAddress", "1@email.com,2@email.com");

    // Optional attachments
    builder.addFormDataPart("attachment1", "FileName1.jpg",
    RequestBody.create(new File("FILEPATH"), MediaType.parse("application/octet-stream")));
    builder.addFormDataPart("attachment1", "FileName2.jpg",
    RequestBody.create(new File("FILEPATH2"), MediaType.parse("application/octet-stream")));

    RequestBody requestBody = builder.build();

    // Build request
    Request request = new Request.Builder()
    .url(apiUrl)
    .addHeader("Authorization", "Basic " + authValue)
    .post(requestBody)
    .build();

    // Send request
    try (Response response = client.newCall(request).execute()) {
    System.out.println("Status: " + response.code());
    System.out.println("Response: " + response.body().string());
    }
    }
    }

C# (.NET HttpClient)


    var apiUrl = "https://api.postrabbit.com/v1/messages";

    // Your API key (NOT username:password, just the key)
    string apiKey = "YOURAPIKEY";

    // Base64 encode exactly what your API expects
    string authValue = Convert.ToBase64String(
    Encoding.ASCII.GetBytes(apiKey));

    using (var client = new HttpClient())
    {
    client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Basic", authValue);

    var form = new MultipartFormDataContent();

    // ---- Required fields ----
    form.Add(new StringContent("from@email.com"), "from");
    form.Add(new StringContent("to@email.com"), "to");
    form.Add(new StringContent("PostRabbit Email is Easy"), "subject");
    //

    // --- At least one of the two fields needs to be set ---
    form.Add(new StringContent(""<b>Hello World</b>""), "HtmlView");
    form.Add(new StringContent("This is a text email"), "TextView");
    //

    // --- Optional Fields ---
    form.Add(new StringContent(DateTimeOffset.UtcNow.AddDays(1).ToString("ddd, dd MMM yyyy HH:mm:ss zzz", CultureInfo.InvariantCulture)), "SendAfterDateTime");
    form.Add(new StringContent("true"), "Tracking");
    form.Add(new StringContent("cc@email.com"), "CcAddress");

    //SuppressHeaders will remove all PostRabbit headers so you can add custom headers
    form.Add(new System.Net.Http.StringContent("true"), "SuppressHeaders");

    //Add custom headers using key:value
    form.Add(new System.Net.Http.StringContent("X-Report-Abuse:Please report abuse for this email to: email@email.com"), "Headers");
    form.Add(new System.Net.Http.StringContent("List-Unsubscribe:<https://www.website.com/emailoptout.aspx?email=email@email.com>, <mailto:bounce@website.com?subject=unsubscribeemail@email.com>"), "Headers");


    List
        bccAddresses = new List
            {
            "1@email.com",
            "2@email.com"
            };

            string bccHeader = string.Join(",", bccAddresses);

            form.Add(new StringContent(bccHeader), "BccAddress");
            //


            //Optional Attachments
            List
                attachments = new List
                    ();

                    attachments.Add("FILEPATH");
                    attachments.Add("FILEPATH2");



                    foreach (string attach in attachments)
                    {
                    var fileBytes = System.IO.File.ReadAllBytes(attach);
                    var fileContent = new ByteArrayContent(fileBytes);
                    string mimeType = System.Web.MimeMapping.GetMimeMapping(attach);
                    fileContent.Headers.ContentType = new MediaTypeHeaderValue(mimeType);


                    form.Add(fileContent, "attachment1", "FileName.jpg");
                    }
                    //

                    var response = client.PostAsync(apiUrl, form).GetAwaiter().GetResult();
                    var body = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();

                    Console.WriteLine("Status: " + response.StatusCode);
                    Console.WriteLine(body);
                    }

PHP (curl)


    
    $apiUrl = "https://api.postrabbit.com/v1/messages";
    $apiKey = "YOURAPIKEY";

    // Base64 encode API key
    $authValue = base64_encode($apiKey);

    // Form fields
    $postFields = [
    "from" => "from@email.com",
    "to" => "to@email.com",
    "subject" => "PostRabbit Email is Easy",
    "HtmlView" => "<b>Hello World</b>",
    "TextView" => "This is a text email",
    "SendAfterDateTime" => gmdate("D, d M Y H:i:s") . " +0000",
    "Tracking" => "true",
    "CcAddress" => "cc@email.com",
    "SuppressHeaders" => "true",
    "Headers" => [
    "X-Report-Abuse:Please report abuse for this email to: email@email.com",
    "List-Unsubscribe:<https://www.website.com/emailoptout.aspx?email=email@email.com>, <mailto:bounce@website.com?subject=unsubscribeemail@email.com>"
    ],
    "BccAddress" => "1@email.com,2@email.com",
    // Attachments
    "attachment1" => new CURLFile("FILEPATH"),
    "attachment1" => new CURLFile("FILEPATH2")
    ];

    // Initialize cURL
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $apiUrl);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Basic $authValue"
    ]);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $postFields);

    // Execute request
    $response = curl_exec($ch);

    if(curl_errno($ch)) {
    echo "Error: " . curl_error($ch);
    } else {
    echo "Response: " . $response;
    }

    curl_close($ch);

Go (net/http)


    package main

    import (
    "bytes"
    "encoding/base64"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
    "strings"
    "time"
    )

    func main() {
    apiUrl := "https://api.postrabbit.com/v1/messages"
    apiKey := "YOURAPIKEY"

    // Base64 encode API key
    authValue := base64.StdEncoding.EncodeToString([]byte(apiKey))

    // Prepare multipart form
    var buf bytes.Buffer
    writer := multipart.NewWriter(&buf)

    // ---- Required fields ----
    writer.WriteField("from", "from@email.com")
    writer.WriteField("to", "to@email.com")
    writer.WriteField("subject", "PostRabbit Email is Easy")

    // --- At least one of the two fields needs to be set ---
    writer.WriteField("HtmlView", "<b>Hello World</b>")
    writer.WriteField("TextView", "This is a text email")

    // --- Optional Fields ---
    sendAfter := time.Now().Add(24 * time.Hour).UTC().Format(time.RFC1123)
    writer.WriteField("SendAfterDateTime", sendAfter)
    writer.WriteField("Tracking", "true")
    writer.WriteField("CcAddress", "cc@email.com")
    writer.WriteField("SuppressHeaders", "true")

    // Custom headers
    writer.WriteField("Headers", "X-Report-Abuse:Please report abuse for this email to: email@email.com")
    writer.WriteField("Headers", "List-Unsubscribe:<https://www.website.com/emailoptout.aspx?email=email@email.com>, <mailto:bounce@website.com?subject=unsubscribeemail@email.com>")

    // BCC
    writer.WriteField("BccAddress", "1@email.com,2@email.com")

    // Optional attachments
    attachFiles := []string{"FILEPATH", "FILEPATH2"}
    for _, path := range attachFiles {
    file, err := os.Open(path)
    if err != nil {
    fmt.Println("Error opening file:", err)
    return
    }
    defer file.Close()
    part, _ := writer.CreateFormFile("attachment1", path)
    io.Copy(part, file)
    }

    writer.Close()

    // Prepare HTTP request
    req, err := http.NewRequest("POST", apiUrl, &buf)
    if err != nil {
    fmt.Println("Error creating request:", err)
    return
    }

    req.Header.Set("Authorization", "Basic "+authValue)
    req.Header.Set("Content-Type", writer.FormDataContentType())

    // Send request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
    fmt.Println("Error sending request:", err)
    return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println("Status:", resp.Status)
    fmt.Println("Response:", string(body))
    }

2. Send MIME Message

POST /v1/messages.mime

Send a raw MIME email (RFC822 format). Supports attachments included inside the MIME structure.

Headers

Content-Type: message/rfc822
Authorization: Basic <base64(apiKey)>

Response

{ "message": "Queued.", "id": "…" }

Code Examples

cURL


    #!/bin/bash

    # === Configuration ===
    API_URL="https://api.postrabbit.com/v1/messages.mime"
    API_KEY="YOURAPIKEY"

    FROM="email@yourdomain.com"
    TO="test@testdomain.com"
    CC="cc@email.com"
    BCC="bcc@email.com"
    SUBJECT="This is a Mime Test"
    TEXT_BODY="text view mime"
    HTML_BODY="<p>This is a PR mime test</p>"
    SEND_AFTER=$(date -u -d "+1 day" +"%a, %d %b %Y %H:%M:%S +0000")
    TRACKING="true"
    SUPPRESS_HEADERS="true"
    X_REPORT_ABUSE="Please report abuse for this email to: email@email.com"
    LIST_UNSUBSCRIBE="<p>https://www.website.com/emailoptout.aspx?Email=test@test.com</p>, <p>mailto:bounce@email.com?subject=unsubscribe test@test.com</p>"

    ATTACHMENTS=("C:/Test/FileName1.jpg" "C:/Test/FileName2.pdf")
    BOUNDARY="----=_Part_0_$(date +%s)"

    # === Build MIME message ===
    {
    echo "From: ${FROM}"
    echo "To: ${TO}"
    echo "Cc: ${CC}"
    echo "Bcc: ${BCC}"
    echo "Subject: ${SUBJECT}"
    echo "SendAfterDateTime: ${SEND_AFTER}"
    echo "Tracking: ${TRACKING}"
    echo "SuppressOurHeaders: ${SUPPRESS_HEADERS}"
    echo "X-Report-Abuse: ${X_REPORT_ABUSE}"
    echo "List-Unsubscribe: ${LIST_UNSUBSCRIBE}"
    echo "MIME-Version: 1.0"
    echo "Content-Type: multipart/mixed; boundary=\"$BOUNDARY\""
    echo
    echo "--$BOUNDARY"
    echo "Content-Type: text/plain; charset=UTF-8"
    echo
    echo "$TEXT_BODY"
    echo
    echo "--$BOUNDARY"
    echo "Content-Type: text/html; charset=UTF-8"
    echo
    echo "$HTML_BODY"
    echo

    # === Add attachments ===
    for FILE in "${ATTACHMENTS[@]}"; do
    if [[ -f "$FILE" ]]; then
    FILENAME=$(basename "$FILE")
    MIMETYPE=$(file --mime-type -b "$FILE")
    echo "--$BOUNDARY"
    echo "Content-Type: $MIMETYPE"
    echo "Content-Disposition: attachment; filename=\"$FILENAME\""
    echo "Content-Transfer-Encoding: base64"
    echo
    base64 "$FILE"
    echo
    fi
    done

    echo "--$BOUNDARY--"

    } > email.mime

    # === Send via cURL ===
    curl -X POST "$API_URL" \
    -H "Authorization: Basic $(echo -n $API_KEY | base64)" \
    -H "Content-Type: message/rfc822" \
    --data-binary @email.mime

JavaScript (Browser fetch)


    async function sendMimeEmail() {
    const apiUrl = "https://api.postrabbit.com/v1/messages.mime";
    const apiKey = "YOURAPIKEY";

    // Base64 encode API key
    const authValue = btoa(apiKey);

    // Email fields
    const from = "email@yourdomain.com";
    const to = "test@testdomain.com";
    const cc = "cc@email.com";
    const bcc = "bcc@email.com";
    const subject = "This is a Mime Test";
    const textBody = "text view mime";
    const htmlBody = "<p>This is a PR mime test</p>";
    const sendAfter = new Date(Date.now() + 24*60*60*1000).toUTCString();
    const tracking = "true";
    const suppressHeaders = "true";
    const xReportAbuse = "Please report abuse for this email to: email@email.com";
    const listUnsubscribe = "<p>https://www.website.com/emailoptout.aspx?Email=test@test.com</p>, <p>mailto:bounce@email.com?subject=unsubscribe test@test.com</p>";

    // Get attachments from file input
    const input = document.getElementById("attachments");
    const files = input.files;

    // Build FormData for multipart upload
    const form = new FormData();
    form.append("from", from);
    form.append("to", to);
    form.append("subject", subject);
    form.append("HtmlView", htmlBody);
    form.append("TextView", textBody);
    form.append("CcAddress", cc);
    form.append("BccAddress", bcc);
    form.append("SendAfterDateTime", sendAfter);
    form.append("Tracking", tracking);
    form.append("SuppressOurHeaders", suppressHeaders);
    form.append("Headers", "X-Report-Abuse:" + xReportAbuse);
    form.append("Headers", "List-Unsubscribe:" + listUnsubscribe);

    // Add attachments
    for (let i = 0; i < files.length; i++) {
    form.append("attachment" + (i+1), files[i], files[i].name);
    }

    // Send request
    try {
    const response = await fetch(apiUrl, {
    method: "POST",
    headers: {
    "Authorization": `Basic ${authValue}`
    },
    body: form
    });

    const result = await response.text();
    console.log("Status:", response.status);
    console.log("Response:", result);
    } catch (error) {
    console.error("Error:", error);
    }

Node.js (axios)


    import fs from "fs";
    import axios from "axios";

    // === Configuration ===
    const apiUrl = "https://api.postrabbit.com/v1/messages.mime";
    const apiKey = "YOURAPIKEY";

    // Base64 encode API key for Basic Auth
    const authValue = Buffer.from(apiKey, "ascii").toString("base64");

    // Email fields
    const from = "email@yourdomain.com";
    const to = "test@testdomain.com";
    const cc = "cc@email.com";
    const bcc = "bcc@email.com";
    const subject = "This is a Mime Test";
    const textBody = "text view mime";
    const htmlBody = "<p>This is a PR mime test</p>";
    const sendAfter = new Date(Date.now() + 24*60*60*1000).toUTCString();
    const tracking = "true";
    const suppressHeaders = "true";
    const xReportAbuse = "Please report abuse for this email to: email@email.com";
    const listUnsubscribe = "<p>https://www.website.com/emailoptout.aspx?Email=test@test.com</p>, <p>mailto:bounce@email.com?subject=unsubscribe test@test.com</p>";

    // Attachments
    const attachments = [
    "C:/Test/FileName1.jpg",
    "C:/Test/FileName2.pdf"
    ];

    // === Build MIME message ===
    const boundary = "----=_NodeMime_" + Date.now();

    let mimeParts = [];

    // Headers
    mimeParts.push(`From: ${from}`);
    mimeParts.push(`To: ${to}`);
    mimeParts.push(`Cc: ${cc}`);
    mimeParts.push(`Bcc: ${bcc}`);
    mimeParts.push(`Subject: ${subject}`);
    mimeParts.push(`SendAfterDateTime: ${sendAfter}`);
    mimeParts.push(`Tracking: ${tracking}`);
    mimeParts.push(`SuppressOurHeaders: ${suppressHeaders}`);
    mimeParts.push(`X-Report-Abuse: ${xReportAbuse}`);
    mimeParts.push(`List-Unsubscribe: ${listUnsubscribe}`);
    mimeParts.push(`MIME-Version: 1.0`);
    mimeParts.push(`Content-Type: multipart/mixed; boundary="${boundary}"`);
    mimeParts.push(""); // blank line

    // Text part
    mimeParts.push(`--${boundary}`);
    mimeParts.push(`Content-Type: text/plain; charset="UTF-8"`);
    mimeParts.push("");
    mimeParts.push(textBody);

    // HTML part
    mimeParts.push(`--${boundary}`);
    mimeParts.push(`Content-Type: text/html; charset="UTF-8"`);
    mimeParts.push("");
    mimeParts.push(htmlBody);

    // Attachments
    attachments.forEach(filePath => {
    if (!fs.existsSync(filePath)) return;
    const content = fs.readFileSync(filePath);
    const base64Content = content.toString("base64");
    const filename = filePath.split("/").pop();
    const mimeType = require("mime-types").lookup(filePath) || "application/octet-stream";

    mimeParts.push(`--${boundary}`);
    mimeParts.push(`Content-Type: ${mimeType}`);
    mimeParts.push(`Content-Disposition: attachment; filename="${filename}"`);
    mimeParts.push(`Content-Transfer-Encoding: base64`);
    mimeParts.push("");
    mimeParts.push(base64Content);
    });

    // Close boundary
    mimeParts.push(`--${boundary}--`);

    // Combine MIME message
    const mimeMessage = mimeParts.join("\r\n");

    // === Send via Axios ===
    axios.post(apiUrl, mimeMessage, {
    headers: {
    "Authorization": `Basic ${authValue}`,
    "Content-Type": "message/rfc822"
    }
    })
    .then(response => {
    console.log("Status:", response.status);
    console.log("Response:", response.data);
    })
    .catch(err => {
    console.error("Error:", err.response ? err.response.data : err.message);
    });

Python (requests)


    import base64
    import requests
    from email.mime.multipart import MIMEMultipart
    from email.mime.text import MIMEText
    from email.mime.application import MIMEApplication
    from datetime import datetime, timedelta
    import os
    import mimetypes

    # === Configuration ===
    api_url = "https://api.postrabbit.com/v1/messages.mime"
    api_key = "YOURAPIKEY"

    auth_value = base64.b64encode(api_key.encode("ascii")).decode("ascii")

    from_addr = "email@yourdomain.com"
    to_addr = "test@testdomain.com"
    cc_addr = "cc@email.com"
    bcc_addr = "bcc@email.com"
    subject = "This is a Mime Test"
    text_body = "text view mime"
    html_body = "<p>This is a PR mime test</p>"
    send_after = (datetime.utcnow() + timedelta(days=1)).strftime("%a, %d %b %Y %H:%M:%S +0000")
    tracking = "true"
    suppress_headers = "true"
    x_report_abuse = "Please report abuse for this email to: email@email.com"
    list_unsubscribe = "<p>https://www.website.com/emailoptout.aspx?Email=test@test.com</p>, <p>mailto:bounce@email.com?subject=unsubscribe test@test.com</p>"

    attachments = [
    r"C:\Test\FileName1.jpg",
    r"C:\Test\FileName2.pdf"
    ]

    # === Build MIME email ===
    msg = MIMEMultipart()
    msg['From'] = from_addr
    msg['To'] = to_addr
    msg['Cc'] = cc_addr
    msg['Bcc'] = bcc_addr
    msg['Subject'] = subject
    msg['SendAfterDateTime'] = send_after
    msg['Tracking'] = tracking
    msg['SuppressOurHeaders'] = suppress_headers
    msg['X-Report-Abuse'] = x_report_abuse
    msg['List-Unsubscribe'] = list_unsubscribe

    # Text and HTML body
    msg.attach(MIMEText(text_body, 'plain'))
    msg.attach(MIMEText(html_body, 'html'))

    # Attach files
    for path in attachments:
    if not os.path.exists(path):
    continue
    mime_type, _ = mimetypes.guess_type(path)
    mime_type = mime_type or "application/octet-stream"
    with open(path, "rb") as f:
    part = MIMEApplication(f.read(), _subtype=mime_type.split('/')[-1])
    part.add_header('Content-Disposition', 'attachment', filename=os.path.basename(path))
    msg.attach(part)

    # Convert MIME message to bytes
    mime_bytes = msg.as_bytes()

    # === Send request ===
    headers = {
    "Authorization": f"Basic {auth_value}",
    "Content-Type": "message/rfc822"
    }

    response = requests.post(api_url, headers=headers, data=mime_bytes)

    print("Status:", response.status_code)
    print("Response:", response.text)

Java (OkHttp)


    import okhttp3.*;
    import java.io.File;
    import java.io.IOException;
    import java.nio.file.Files;
    import java.util.Base64;

    public class PostRabbitMimeOkHttp {

    public static void main(String[] args) throws IOException {
    String apiUrl = "https://api.postrabbit.com/v1/messages.mime";
    String apiKey = "YOURAPIKEY";

    // Base64 encode API key
    String authValue = Base64.getEncoder().encodeToString(apiKey.getBytes("ASCII"));

    // Email fields
    String from = "email@yourdomain.com";
    String to = "test@testdomain.com";
    String cc = "cc@email.com";
    String bcc = "bcc@email.com";
    String subject = "This is a Mime Test";
    String textBody = "text view mime";
    String htmlBody = "<p>This is a PR mime test</p>";
    String sendAfter = java.time.ZonedDateTime.now().plusDays(1)
    .format(java.time.format.DateTimeFormatter.RFC_1123_DATE_TIME);
    String tracking = "true";
    String suppressHeaders = "true";
    String xReportAbuse = "Please report abuse for this email to: email@email.com";
    String listUnsubscribe = "<p>https://www.website.com/emailoptout.aspx?Email=test@test.com</p>, <p>mailto:bounce@email.com?subject=unsubscribe test@test.com</p>";

    // Attachments
    String[] attachments = {"C:/Test/FileName1.jpg", "C:/Test/FileName2.pdf"};

    // === Build MIME message ===
    String boundary = "----=_OkHttpMime_" + System.currentTimeMillis();
    StringBuilder mimeBuilder = new StringBuilder();

    // Headers
    mimeBuilder.append("From: ").append(from).append("\r\n");
    mimeBuilder.append("To: ").append(to).append("\r\n");
    mimeBuilder.append("Cc: ").append(cc).append("\r\n");
    mimeBuilder.append("Bcc: ").append(bcc).append("\r\n");
    mimeBuilder.append("Subject: ").append(subject).append("\r\n");
    mimeBuilder.append("SendAfterDateTime: ").append(sendAfter).append("\r\n");
    mimeBuilder.append("Tracking: ").append(tracking).append("\r\n");
    mimeBuilder.append("SuppressOurHeaders: ").append(suppressHeaders).append("\r\n");
    mimeBuilder.append("X-Report-Abuse: ").append(xReportAbuse).append("\r\n");
    mimeBuilder.append("List-Unsubscribe: ").append(listUnsubscribe).append("\r\n");
    mimeBuilder.append("MIME-Version: 1.0\r\n");
    mimeBuilder.append("Content-Type: multipart/mixed; boundary=\"").append(boundary).append("\"\r\n\r\n");

    // Text part
    mimeBuilder.append("--").append(boundary).append("\r\n");
    mimeBuilder.append("Content-Type: text/plain; charset=\"UTF-8\"\r\n\r\n");
    mimeBuilder.append(textBody).append("\r\n\r\n");

    // HTML part
    mimeBuilder.append("--").append(boundary).append("\r\n");
    mimeBuilder.append("Content-Type: text/html; charset=\"UTF-8\"\r\n\r\n");
    mimeBuilder.append(htmlBody).append("\r\n\r\n");

    // Attachments
    for (String path : attachments) {
    File file = new File(path);
    if (!file.exists()) continue;

    String mimeType = Files.probeContentType(file.toPath());
    if (mimeType == null) mimeType = "application/octet-stream";
    byte[] fileBytes = Files.readAllBytes(file.toPath());
    String base64Content = Base64.getEncoder().encodeToString(fileBytes);

    mimeBuilder.append("--").append(boundary).append("\r\n");
    mimeBuilder.append("Content-Type: ").append(mimeType).append("\r\n");
    mimeBuilder.append("Content-Disposition: attachment; filename=\"").append(file.getName()).append("\"\r\n");
    mimeBuilder.append("Content-Transfer-Encoding: base64\r\n\r\n");
    mimeBuilder.append(base64Content).append("\r\n\r\n");
    }

    // Close boundary
    mimeBuilder.append("--").append(boundary).append("--\r\n");

    String mimeMessage = mimeBuilder.toString();

    // === Send via OkHttp ===
    OkHttpClient client = new OkHttpClient();

    RequestBody body = RequestBody.create(
    mimeMessage,
    MediaType.parse("message/rfc822")
    );

    Request request = new Request.Builder()
    .url(apiUrl)
    .addHeader("Authorization", "Basic " + authValue)
    .post(body)
    .build();

    try (Response response = client.newCall(request).execute()) {
    System.out.println("Status: " + response.code());
    System.out.println("Response: " + response.body().string());
    }
    }
    }

C# (.NET HttpClient)



    var apiUrl = "https://api.postrabbit.com/v1/messages.mime";

    // Your API key (NOT username:password, just the key)
    string apiKey = "YOURAPIKEY";

    // Base64 encode exactly what your API expects
    string authValue = Convert.ToBase64String(
    Encoding.ASCII.GetBytes(apiKey));

    using (var client = new HttpClient())
    {
    client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Basic", authValue);

    // ---- Required fields ----
    MimeMessage email = new MimeMessage();

    email.From.Add(new MailboxAddress("email@yourdomain.com", "email@yourdomain.com"));
    email.To.Add(MailboxAddress.Parse("test@testdomain.com"));
    email.Subject = "This is a Mime Test";

    BodyBuilder bodyBuilder = new BodyBuilder();

    bodyBuilder.HtmlBody = "<p>This is a PR mime test</p>";
    bodyBuilder.TextBody = "text view mime";

    email.Cc.Add(new MailboxAddress("cc@email.com", "cc@email.com"));
    email.Bcc.Add(new MailboxAddress("bcc@email.com", "bcc@email.com"));

    email.Headers.Add("SendAfterDateTime", DateTimeOffset.UtcNow.AddDays(1).ToString("ddd, dd MMM yyyy HH:mm:ss zzz", CultureInfo.InvariantCulture));
    email.Headers.Add("Tracking", "true");
    email.Headers.Add("SuppressOurHeaders", "true");

    email.Headers.Add("X-Report-Abuse", "Please report abuse for this email to: email@email.com");
    email.Headers.Add("List-Unsubscribe",  "<p>https: //www.website.com/emailoptout.aspx?Email=test@test.com</p>, " + "<p>mailto:bounce@email.com?subject =unsubscribe test@test.com</p>");

    List
        attachments = new List
            {
            "C:\Test\FileName1.jpg",
            "C:\Test\FileName2.pdf"
            };

            foreach (var path in attachments)
            {
            if (!System.IO.File.Exists(path))
            continue;

            var mimeType = System.Web.MimeMapping.GetMimeMapping(path);

            bodyBuilder.Attachments.Add(
            path,                       // file path (MimeKit reads it)
            MimeKit.ContentType.Parse(mimeType) // correct MIME type
            );
            }
            email.Body = bodyBuilder.ToMessageBody();

            byte[] mimeBytes;

            using (var ms = new MemoryStream())
            {
            email.WriteTo(ms);
            mimeBytes = ms.ToArray();
            }

            var content = new ByteArrayContent(mimeBytes);
            content.Headers.ContentType =
            new MediaTypeHeaderValue("message/rfc822");


            var response = client.PostAsync(apiUrl, content).GetAwaiter().GetResult();
            var body = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();

            Console.WriteLine("Status: " + response.StatusCode);
            Console.WriteLine(body);

            }

PHP (curl)


    $apiUrl = "https://api.postrabbit.com/v1/messages.mime";
    $apiKey = "YOURAPIKEY";

    // Base64 encode API key
    $authValue = base64_encode($apiKey);

    // Email fields
    $from = "email@yourdomain.com";
    $to = "test@testdomain.com";
    $cc = "cc@email.com";
    $bcc = "bcc@email.com";
    $subject = "This is a Mime Test";
    $textBody = "text view mime";
    $htmlBody = "<p>This is a PR mime test</p>";
    $sendAfter = gmdate("D, d M Y H:i:s") . " +0000";
    $tracking = "true";
    $suppressHeaders = "true";
    $xReportAbuse = "Please report abuse for this email to: email@email.com";
    $listUnsubscribe = "<p>https://www.website.com/emailoptout.aspx?Email=test@test.com</p>, <p>mailto:bounce@email.com?subject=unsubscribe test@test.com</p>";

    // Attachments
    $attachments = [
    "C:/Test/FileName1.jpg",
    "C:/Test/FileName2.pdf"
    ];

    // === Build MIME message ===
    $boundary = "----=_PHPMime_" . time();
    $mime = "";

    // Headers
    $mime .= "From: $from\r\n";
    $mime .= "To: $to\r\n";
    $mime .= "Cc: $cc\r\n";
    $mime .= "Bcc: $bcc\r\n";
    $mime .= "Subject: $subject\r\n";
    $mime .= "SendAfterDateTime: $sendAfter\r\n";
    $mime .= "Tracking: $tracking\r\n";
    $mime .= "SuppressOurHeaders: $suppressHeaders\r\n";
    $mime .= "X-Report-Abuse: $xReportAbuse\r\n";
    $mime .= "List-Unsubscribe: $listUnsubscribe\r\n";
    $mime .= "MIME-Version: 1.0\r\n";
    $mime .= "Content-Type: multipart/mixed; boundary=\"$boundary\"\r\n\r\n";

    // Text part
    $mime .= "--$boundary\r\n";
    $mime .= "Content-Type: text/plain; charset=UTF-8\r\n\r\n";
    $mime .= "$textBody\r\n\r\n";

    // HTML part
    $mime .= "--$boundary\r\n";
    $mime .= "Content-Type: text/html; charset=UTF-8\r\n\r\n";
    $mime .= "$htmlBody\r\n\r\n";

    // Attachments
    foreach ($attachments as $file) {
    if (!file_exists($file)) continue;

    $mimeType = mime_content_type($file) ?: "application/octet-stream";
    $content = chunk_split(base64_encode(file_get_contents($file)));
    $filename = basename($file);

    $mime .= "--$boundary\r\n";
    $mime .= "Content-Type: $mimeType\r\n";
    $mime .= "Content-Disposition: attachment; filename=\"$filename\"\r\n";
    $mime .= "Content-Transfer-Encoding: base64\r\n\r\n";
    $mime .= "$content\r\n\r\n";
    }

    // Close boundary
    $mime .= "--$boundary--\r\n";

    // === Send via cURL ===
    $ch = curl_init($apiUrl);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Basic $authValue",
    "Content-Type: message/rfc822"
    ]);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $mime);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $response = curl_exec($ch);

    if (curl_errno($ch)) {
    echo "cURL Error: " . curl_error($ch);
    } else {
    echo "Status: " . curl_getinfo($ch, CURLINFO_HTTP_CODE) . "\n";
    echo "Response:\n$response";
    }

    curl_close($ch);

Go (net/http)


    package main

    import (
    "bytes"
    "encoding/base64"
    "fmt"
    "io/ioutil"
    "mime"
    "net/http"
    "os"
    "path/filepath"
    "time"
    )

    func main() {
    apiURL := "https://api.postrabbit.com/v1/messages.mime"
    apiKey := "YOURAPIKEY"

    // Base64 encode API key for Basic Auth
    authValue := base64.StdEncoding.EncodeToString([]byte(apiKey))

    // Email fields
    from := "email@yourdomain.com"
    to := "test@testdomain.com"
    cc := "cc@email.com"
    bcc := "bcc@email.com"
    subject := "This is a Mime Test"
    textBody := "text view mime"
    htmlBody := "<p>This is a PR mime test</p>"
    sendAfter := time.Now().Add(24 * time.Hour).UTC().Format("Mon, 02 Jan 2006 15:04:05 +0000")
    tracking := "true"
    suppressHeaders := "true"
    xReportAbuse := "Please report abuse for this email to: email@email.com"
    listUnsubscribe := "<p>https://www.website.com/emailoptout.aspx?Email=test@test.com</p>, <p>mailto:bounce@email.com?subject=unsubscribe test@test.com</p>"

    attachments := []string{
    "C:/Test/FileName1.jpg",
    "C:/Test/FileName2.pdf",
    }

    // === Build MIME message ===
    boundary := fmt.Sprintf("----=_GoMime_%d", time.Now().Unix())
    var mimeBuf bytes.Buffer

    // Headers
    mimeBuf.WriteString(fmt.Sprintf("From: %s\r\n", from))
    mimeBuf.WriteString(fmt.Sprintf("To: %s\r\n", to))
    mimeBuf.WriteString(fmt.Sprintf("Cc: %s\r\n", cc))
    mimeBuf.WriteString(fmt.Sprintf("Bcc: %s\r\n", bcc))
    mimeBuf.WriteString(fmt.Sprintf("Subject: %s\r\n", subject))
    mimeBuf.WriteString(fmt.Sprintf("SendAfterDateTime: %s\r\n", sendAfter))
    mimeBuf.WriteString(fmt.Sprintf("Tracking: %s\r\n", tracking))
    mimeBuf.WriteString(fmt.Sprintf("SuppressOurHeaders: %s\r\n", suppressHeaders))
    mimeBuf.WriteString(fmt.Sprintf("X-Report-Abuse: %s\r\n", xReportAbuse))
    mimeBuf.WriteString(fmt.Sprintf("List-Unsubscribe: %s\r\n", listUnsubscribe))
    mimeBuf.WriteString("MIME-Version: 1.0\r\n")
    mimeBuf.WriteString(fmt.Sprintf("Content-Type: multipart/mixed; boundary=\"%s\"\r\n\r\n", boundary))

    // Text part
    mimeBuf.WriteString(fmt.Sprintf("--%s\r\n", boundary))
    mimeBuf.WriteString("Content-Type: text/plain; charset=\"UTF-8\"\r\n\r\n")
    mimeBuf.WriteString(fmt.Sprintf("%s\r\n\r\n", textBody))

    // HTML part
    mimeBuf.WriteString(fmt.Sprintf("--%s\r\n", boundary))
    mimeBuf.WriteString("Content-Type: text/html; charset=\"UTF-8\"\r\n\r\n")
    mimeBuf.WriteString(fmt.Sprintf("%s\r\n\r\n", htmlBody))

    // Attachments
    for _, filePath := range attachments {
    if _, err := os.Stat(filePath); os.IsNotExist(err) {
    continue
    }

    data, err := ioutil.ReadFile(filePath)
    if err != nil {
    fmt.Printf("Failed to read file %s: %v\n", filePath, err)
    continue
    }

    filename := filepath.Base(filePath)
    mimeType := mime.TypeByExtension(filepath.Ext(filePath))
    if mimeType == "" {
    mimeType = "application/octet-stream"
    }

    mimeBuf.WriteString(fmt.Sprintf("--%s\r\n", boundary))
    mimeBuf.WriteString(fmt.Sprintf("Content-Type: %s\r\n", mimeType))
    mimeBuf.WriteString(fmt.Sprintf("Content-Disposition: attachment; filename=\"%s\"\r\n", filename))
    mimeBuf.WriteString("Content-Transfer-Encoding: base64\r\n\r\n")

    encoded := base64.StdEncoding.EncodeToString(data)
    // Split base64 lines to 76 chars per RFC
    for i := 0; i < len(encoded); i += 76 {
    end := i + 76
    if end > len(encoded) {
    end = len(encoded)
    }
    mimeBuf.WriteString(encoded[i:end] + "\r\n")
    }
    mimeBuf.WriteString("\r\n")
    }

    // Close boundary
    mimeBuf.WriteString(fmt.Sprintf("--%s--\r\n", boundary))

    // === Send via HTTP POST ===
    req, err := http.NewRequest("POST", apiURL, &mimeBuf)
    if err != nil {
    panic(err)
    }
    req.Header.Add("Authorization", "Basic "+authValue)
    req.Header.Add("Content-Type", "message/rfc822")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
    panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Printf("Status: %d\n", resp.StatusCode)
    fmt.Printf("Response:\n%s\n", body)
    }

3. Retrieve Email

GET /v1/getmessage/{id}

Retrieve full email details by Message ID.

Response

{
      "EmailID": "abcd1234",
      "FromAddress": "...",
      "ToAddress": "...",
      "Subject": "...",
      "CcAddress": "...",
      "BccAddress": "...",
      "Status": "Delivered",
      "DateSent": "Tue, 20 Feb 2025 09:12:00 +0000",
      "TextView": "...",
      "HtmlView": "..."
}

Code Examples

cURL


    MESSAGE_ID="YOURMESSAGEID"
    API_KEY="YOURAPIKEY"

    AUTH_VALUE=$(printf "%s" "$API_KEY" | base64)

    curl -i \
    -H "Authorization: Basic $AUTH_VALUE" \
    -H "Accept: application/json" \
    "https://api.postrabbit.com/v1/getmessage/$MESSAGE_ID"

JavaScript (Browser fetch)


    const messageID = "YOURMESSAGEID";
    const apiKey = "YOURAPIKEY";

    const apiUrl = `https://api.postrabbit.com/v1/getmessage/${messageID}`;

    // Base64 encode API key
    const authValue = btoa(apiKey); // browser-safe Base64

    fetch(apiUrl, {
    method: "GET",
    headers: {
    "Authorization": `Basic ${authValue}`,
    "Accept": "application/json"
    }
    })
    .then(response => {
    console.log("Status Code:", response.status);
    return response.text();
    })
    .then(body => {
    console.log("Response:");
    console.log(body);
    })
    .catch(err => {
    console.error("Error:", err);
    });

Node.js (axios)


    const axios = require("axios");

    const messageID = "YOURMESSAGEID";
    const apiKey = "YOURAPIKEY";

    const apiUrl = `https://api.postrabbit.com/v1/getmessage/${messageID}`;

    // Base64 encode API key (same as Convert.ToBase64String)
    const authValue = Buffer.from(apiKey, "ascii").toString("base64");

    axios.get(apiUrl, {
    headers: {
    "Authorization": `Basic ${authValue}`,
    "Accept": "application/json"
    }
    })
    .then(response => {
    console.log("Status Code:", response.status);
    console.log("Response:");
    console.log(response.data);
    })
    .catch(error => {
    if (error.response) {
    // Server returned a non-2xx status
    console.log("Status Code:", error.response.status);
    console.log("Response:");
    console.log(error.response.data);
    } else {
    // Network or other error
    console.error("Error:", error.message);
    }
    });

Python (requests)


import base64
import requests

message_id = "YOURMESSAGEID"
api_key = "YOURAPIKEY"

api_url = f"https://api.postrabbit.com/v1/getmessage/{message_id}"

# Base64 encode API key (same as Convert.ToBase64String)
auth_value = base64.b64encode(api_key.encode("ascii")).decode("ascii")

headers = {
    "Authorization": f"Basic {auth_value}",
    "Accept": "application/json"
}

response = requests.get(api_url, headers=headers)

print("Status Code:", response.status_code)
print("Response:")
print(response.text)

Java (OkHttp)



    String messageID = "YOURMESSAGEID";
    String apiKey = "YOURAPIKEY";

    String apiUrl = "https://api.postrabbit.com/v1/getmessage/" + messageID;

    // Base64 encode API key (same as Convert.ToBase64String)
    String authValue = Base64.getEncoder()
    .encodeToString(apiKey.getBytes(java.nio.charset.StandardCharsets.US_ASCII));

    OkHttpClient client = new OkHttpClient();

    Request request = new Request.Builder()
    .url(apiUrl)
    .addHeader("Authorization", "Basic " + authValue)
    .addHeader("Accept", "application/json")
    .get()
    .build();

    try (Response response = client.newCall(request).execute()) {

    String responseBody = response.body() != null
    ? response.body().string()
    : "";

    System.out.println("Status Code: " + response.code());
    System.out.println("Response:");
    System.out.println(responseBody);
    }
    catch (Exception ex) {
    ex.printStackTrace();
    }

C# (.NET HttpClient)


    string messageID = "YOURMESSAGEID";

    var apiUrl = "https://api.postrabbit.com/v1/getmessage/" + messageID;
    string apiKey = "YOURAPIKEY";

    string authValue = Convert.ToBase64String(
    Encoding.ASCII.GetBytes(apiKey));

    using (var client = new HttpClient())
    {

    client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Basic", authValue);

    HttpResponseMessage response =
    client.GetAsync(apiUrl)
    .GetAwaiter()
    .GetResult();

    string responseBody =
    response.Content.ReadAsStringAsync()
    .GetAwaiter()
    .GetResult();

    Console.WriteLine("Status Code: " + response.StatusCode);
    Console.WriteLine("Response:");
    Console.WriteLine(responseBody);
    }

Go (net/http)



package main

import (
	"encoding/base64"
	"fmt"
	"io"
	"net/http"
)

func main() {
	messageID := "YOURMESSAGEID"
	apiKey := "YOURAPIKEY"

	apiURL := "https://api.postrabbit.com/v1/getmessage/" + messageID

	// Base64 encode API key (same as Convert.ToBase64String)
	authValue := base64.StdEncoding.EncodeToString([]byte(apiKey))

	// Create HTTP request
	req, err := http.NewRequest("GET", apiURL, nil)
	if err != nil {
		panic(err)
	}

	// Add Authorization header
	req.Header.Add("Authorization", "Basic "+authValue)
	req.Header.Add("Accept", "application/json")

	// Create client and send request
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	// Read response body
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}

	// Output results
	fmt.Println("Status Code:", resp.Status)
	fmt.Println("Response:")
	fmt.Println(string(body))
}
}

4. Get Email Status

GET /v1/getstatus/{id}

Returns only the email status.

Response

{
    "EmailID": "abcd1234",
    "Status": "Queued"
}

Code Examples

cURL


    MESSAGE_ID="YOURMESSAGEID"
    API_KEY="YOURAPIKEY"

    # Base64 encode the API key
    AUTH_VALUE=$(printf "%s" "$API_KEY" | base64)

    curl -i \
    -H "Authorization: Basic $AUTH_VALUE" \
    -H "Accept: application/json" \
    "https://api.postrabbit.com/v1/getstatus/$MESSAGE_ID"

JavaScript (Browser fetch)


    const messageID = "YOURMESSAGEID";
    const apiKey = "YOURAPIKEY";

    const apiUrl = `https://api.postrabbit.com/v1/getstatus/${messageID}`;

    // Base64 encode API key
    const authValue = btoa(apiKey); // browser-safe Base64

    fetch(apiUrl, {
    method: "GET",
    headers: {
    "Authorization": `Basic ${authValue}`,
    "Accept": "application/json"
    }
    })
    .then(response => {
    console.log("Status Code:", response.status);
    return response.text();
    })
    .then(body => {
    console.log("Response:");
    console.log(body);
    })
    .catch(err => {
    console.error("Error:", err);
    });

Node.js (axios)


    const axios = require("axios");

    const messageID = "YOURMESSAGEID";
    const apiKey = "YOURAPIKEY";

    const apiUrl = `https://api.postrabbit.com/v1/getstatus/${messageID}`;

    // Base64 encode API key (same as Convert.ToBase64String)
    const authValue = Buffer.from(apiKey, "ascii").toString("base64");

    axios.get(apiUrl, {
    headers: {
    "Authorization": `Basic ${authValue}`,
    "Accept": "application/json"
    }
    })
    .then(response => {
    console.log("Status Code:", response.status);
    console.log("Response:");
    console.log(response.data);
    })
    .catch(error => {
    if (error.response) {
    // Server returned a non-2xx status
    console.log("Status Code:", error.response.status);
    console.log("Response:");
    console.log(error.response.data);
    } else {
    console.error("Error:", error.message);
    }
    });

Python (requests)


    message_id = "YOURMESSAGEID"
    api_key = "YOURAPIKEY"

    api_url = f"https://api.postrabbit.com/v1/getstatus/{message_id}"

    # Base64 encode API key (same as Convert.ToBase64String)
    auth_value = base64.b64encode(api_key.encode("ascii")).decode("ascii")

    headers = {
    "Authorization": f"Basic {auth_value}",
    "Accept": "application/json"
    }

    response = requests.get(api_url, headers=headers)

    print("Status Code:", response.status_code)
    print("Response:")
    print(response.text)

    # Example Failure Response:
    # {"message":"Invalid Message Id.","errorCode":"InvalidMessageId"}

    # Example Success Response:
    # {"emailID":"YOURMESSAGEID","status":"Delivered"}

Java (OkHttp)


    String messageID = "YOURMESSAGEID";
    String apiKey = "YOURAPIKEY";

    String apiUrl = "https://api.postrabbit.com/v1/getstatus/" + messageID;

    // Base64 encode API key (same as Convert.ToBase64String)
    String authValue = Base64.getEncoder()
    .encodeToString(apiKey.getBytes(StandardCharsets.US_ASCII));

    OkHttpClient client = new OkHttpClient();

    Request request = new Request.Builder()
    .url(apiUrl)
    .addHeader("Authorization", "Basic " + authValue)
    .addHeader("Accept", "application/json")
    .get()
    .build();

    try (Response response = client.newCall(request).execute()) {

    String responseBody = response.body() != null
    ? response.body().string()
    : "";

    System.out.println("Status Code: " + response.code());
    System.out.println("Response:");
    System.out.println(responseBody);

    // Example Failure Response:
    // {"message":"Invalid Message Id.","errorCode":"InvalidMessageId"}

    // Example Success Response:
    // {"emailID":"YOURMESSAGEID","status":"Delivered"}
    }
    catch (Exception ex) {
    ex.printStackTrace();
    }

C# (.NET HttpClient)


    string messageID = "YOURMESSAGEID";

    var apiUrl = "https://api.postrabbit.com/v1/getstatus/" + messageID;
    string apiKey = "YOURAPIKEY";

    string authValue = Convert.ToBase64String(
    Encoding.ASCII.GetBytes(apiKey));

    using (var client = new HttpClient())
    {

    client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Basic", authValue);

    HttpResponseMessage response =
    client.GetAsync(apiUrl)
    .GetAwaiter()
    .GetResult();

    string responseBody =
    response.Content.ReadAsStringAsync()
    .GetAwaiter()
    .GetResult();

    Console.WriteLine("Status Code: " + response.StatusCode);
    Console.WriteLine("Response:");
    Console.WriteLine(responseBody);

    //Example Failure Reaponse:  "{\"message\":\"Invalid Message Id.\",\"errorCode\":\"InvalidMessageId\"}"
    //Example Success Response:  "{\"emailID\":\"YOURMESSAGEID\",\"status\":\"Delivered\"}"
    }

PHP (curl)



    $messageID = "YOURMESSAGEID";
    $apiKey = "YOURAPIKEY";

    $apiUrl = "https://api.postrabbit.com/v1/getstatus/" . $messageID;

    // Base64 encode API key (same as Convert.ToBase64String)
    $authValue = base64_encode($apiKey);

    $ch = curl_init();

    curl_setopt_array($ch, [
    CURLOPT_URL => $apiUrl,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPGET => true,
    CURLOPT_HTTPHEADER => [
    "Authorization: Basic $authValue",
    "Accept: application/json"
    ]
    ]);

    $responseBody = curl_exec($ch);
    $httpStatus   = curl_getinfo($ch, CURLINFO_HTTP_CODE);

    if ($responseBody === false) {
    $error = curl_error($ch);
    curl_close($ch);
    die("cURL Error: " . $error);
    }

    curl_close($ch);

    echo "Status Code: " . $httpStatus . PHP_EOL;
    echo "Response:" . PHP_EOL;
    echo $responseBody . PHP_EOL;

    // Example Failure Response:
    // {"message":"Invalid Message Id.","errorCode":"InvalidMessageId"}

    // Example Success Response:
    // {"emailID":"YOURMESSAGEID","status":"Delivered"}

Go (net/http)


    package main

    import (
    "encoding/base64"
    "fmt"
    "io"
    "net/http"
    )

    func main() {
    messageID := "YOURMESSAGEID"
    apiKey := "YOURAPIKEY"

    apiURL := "https://api.postrabbit.com/v1/getstatus/" + messageID

    // Base64 encode API key (same as Convert.ToBase64String)
    authValue := base64.StdEncoding.EncodeToString([]byte(apiKey))

    // Create HTTP request
    req, err := http.NewRequest("GET", apiURL, nil)
    if err != nil {
    panic(err)
    }

    // Add headers
    req.Header.Add("Authorization", "Basic "+authValue)
    req.Header.Add("Accept", "application/json")

    // Create HTTP client and send request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
    panic(err)
    }
    defer resp.Body.Close()

    // Read response body
    body, err := io.ReadAll(resp.Body)
    if err != nil {
    panic(err)
    }

    // Output results
    fmt.Println("Status Code:", resp.StatusCode)
    fmt.Println("Response:")
    fmt.Println(string(body))

    // Example Failure Response:
    // {"message":"Invalid Message Id.","errorCode":"InvalidMessageId"}

    // Example Success Response:
    // {"emailID":"YOURMESSAGEID","status":"Delivered"}
    }

5. Cancel Unsent Email

GET /v1/cancelemail/{id}

This endpoint cancels an email only if it is in:

Queued
Pending
Error
OptedOut

Responses

{"status":"email cancelled", "EmailID":"abcd1234"}

{"status":"email already sent", "EmailID":"abcd1234"}

{"status":"email could not be cancelled", "EmailID":"abcd1234"}

Code Examples

cURL


    MESSAGE_ID="YOURMESSAGEID"
    API_KEY="YOURAPIKEY"

    # Base64 encode the API key
    AUTH_VALUE=$(printf "%s" "$API_KEY" | base64)

    curl -i \
    -H "Authorization: Basic $AUTH_VALUE" \
    -H "Accept: application/json" \
    "https://api.postrabbit.com/v1/cancelemail/$MESSAGE_ID"

JavaScript (Browser fetch)


    const messageID = "YOURMESSAGEID";
    const apiKey = "YOURAPIKEY";

    const apiUrl = `https://api.postrabbit.com/v1/cancelemail/${messageID}`;

    // Base64 encode API key (browser-safe)
    const authValue = btoa(apiKey);

    fetch(apiUrl, {
    method: "GET",
    headers: {
    "Authorization": `Basic ${authValue}`,
    "Accept": "application/json"
    }
    })
    .then(response => {
    console.log("Status Code:", response.status);
    return response.text();
    })
    .then(body => {
    console.log("Response:");
    console.log(body);
    })
    .catch(err => {
    console.error("Error:", err);
    });

Node.js (axios)


    const axios = require("axios");

    const messageID = "YOURMESSAGEID";
    const apiKey = "YOURAPIKEY";

    const apiUrl = `https://api.postrabbit.com/v1/cancelemail/${messageID}`;

    // Base64 encode API key (like Convert.ToBase64String)
    const authValue = Buffer.from(apiKey, "ascii").toString("base64");

    axios.get(apiUrl, {
    headers: {
    "Authorization": `Basic ${authValue}`,
    "Accept": "application/json"
    }
    })
    .then(response => {
    console.log("Status Code:", response.status);
    console.log("Response:");
    console.log(response.data);
    })
    .catch(error => {
    if (error.response) {
    console.log("Status Code:", error.response.status);
    console.log("Response:");
    console.log(error.response.data);
    } else {
    console.error("Error:", error.message);
    }
    });

Python (requests)


    message_id = "YOURMESSAGEID"
    api_key = "YOURAPIKEY"

    api_url = f"https://api.postrabbit.com/v1/cancelemail/{message_id}"

    # Base64 encode API key (like Convert.ToBase64String)
    auth_value = base64.b64encode(api_key.encode("ascii")).decode("ascii")

    headers = {
    "Authorization": f"Basic {auth_value}",
    "Accept": "application/json"
    }

    response = requests.get(api_url, headers=headers)

    print("Status Code:", response.status_code)
    print("Response:")
    print(response.text)

    # Example Failure Response:
    # {"status":"email already sent","emailID":"YOURMESSAGEID"}

    # Example Success Response:
    # {"status":"email cancelled","emailID":"YOURMESSAGEID"}

Java (OkHttp)


    String messageID = "YOURMESSAGEID";
    String apiKey = "YOURAPIKEY";

    String apiUrl = "https://api.postrabbit.com/v1/cancelemail/" + messageID;

    // Base64 encode API key (same as Convert.ToBase64String)
    String authValue = Base64.getEncoder()
    .encodeToString(apiKey.getBytes(StandardCharsets.US_ASCII));

    OkHttpClient client = new OkHttpClient();

    Request request = new Request.Builder()
    .url(apiUrl)
    .addHeader("Authorization", "Basic " + authValue)
    .addHeader("Accept", "application/json")
    .get()
    .build();

    try (Response response = client.newCall(request).execute()) {

    String responseBody = response.body() != null
    ? response.body().string()
    : "";

    System.out.println("Status Code: " + response.code());
    System.out.println("Response:");
    System.out.println(responseBody);

    // Example Failure Response:
    // {"status":"email already sent","emailID":"YOURMESSAGEID"}

    // Example Success Response:
    // {"status":"email cancelled","emailID":"YOURMESSAGEID"}

    } catch (Exception ex) {
    ex.printStackTrace();
    }

C# (.NET HttpClient)


    string messageID = "YOURMESSAGEID";

    var apiUrl = "https://api.postrabbit.com/v1/cancelemail/" + messageID;
    string apiKey = "YOURAPIKEY";

    string authValue = Convert.ToBase64String(
    Encoding.ASCII.GetBytes(apiKey));

    using (var client = new HttpClient())
    {
    // Your controller expects:
    // Authorization: Basic base64(apiKey)

    client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Basic", authValue);

    // GET request
    HttpResponseMessage response =
    client.GetAsync(apiUrl)
    .GetAwaiter()
    .GetResult();

    string responseBody =
    response.Content.ReadAsStringAsync()
    .GetAwaiter()
    .GetResult();

    Console.WriteLine("Status Code: " + response.StatusCode);
    Console.WriteLine("Response:");
    Console.WriteLine(responseBody);

    //Failure Response:  "{\"status\":\"email already sent\",\"emailID\":\"YOURMESSAGEID\"}"
    //Success Response:  "{\"status\":\"email cancelled\",\"emailID\":\"YOURMESSAGEID\"}"
    }

PHP (curl)


    $messageID = "YOURMESSAGEID";
    $apiKey = "YOURAPIKEY";

    $apiUrl = "https://api.postrabbit.com/v1/cancelemail/" . $messageID;

    // Base64 encode API key (same as Convert.ToBase64String)
    $authValue = base64_encode($apiKey);

    // Initialize cURL
    $ch = curl_init();

    curl_setopt_array($ch, [
    CURLOPT_URL => $apiUrl,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPGET => true,
    CURLOPT_HTTPHEADER => [
    "Authorization: Basic $authValue",
    "Accept: application/json"
    ]
    ]);

    $responseBody = curl_exec($ch);
    $httpStatus   = curl_getinfo($ch, CURLINFO_HTTP_CODE);

    if ($responseBody === false) {
    $error = curl_error($ch);
    curl_close($ch);
    die("cURL Error: " . $error);
    }

    curl_close($ch);

    echo "Status Code: " . $httpStatus . PHP_EOL;
    echo "Response:" . PHP_EOL;
    echo $responseBody . PHP_EOL;

    // Example Failure Response:
    // {"status":"email already sent","emailID":"YOURMESSAGEID"}

    // Example Success Response:
    // {"status":"email cancelled","emailID":"YOURMESSAGEID"}

Go (net/http)


    package main

    import (
    "encoding/base64"
    "fmt"
    "io"
    "net/http"
    )

    func main() {
    messageID := "YOURMESSAGEID"
    apiKey := "YOURAPIKEY"

    apiURL := "https://api.postrabbit.com/v1/cancelemail/" + messageID

    // Base64 encode API key (like Convert.ToBase64String)
    authValue := base64.StdEncoding.EncodeToString([]byte(apiKey))

    // Create HTTP request
    req, err := http.NewRequest("GET", apiURL, nil)
    if err != nil {
    panic(err)
    }

    // Add headers
    req.Header.Add("Authorization", "Basic "+authValue)
    req.Header.Add("Accept", "application/json")

    // Create HTTP client and send request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
    panic(err)
    }
    defer resp.Body.Close()

    // Read response body
    body, err := io.ReadAll(resp.Body)
    if err != nil {
    panic(err)
    }

    // Print results
    fmt.Println("Status Code:", resp.StatusCode)
    fmt.Println("Response:")
    fmt.Println(string(body))

    // Example Failure Response:
    // {"status":"email already sent","emailID":"YOURMESSAGEID"}

    // Example Success Response:
    // {"status":"email cancelled","emailID":"YOURMESSAGEID"}
    }
    }

Contents

PostRabbit Transactional Email API Documentation

Base URL

Authentication

Header Format:

Example (Linux/Mac)

Header sent:

Example (C# .NET 4.7.2):

1. Send Message — multipart/form-data

POST /v1/messages

Headers

Content-Type:

Parameters

Response (JSON)

Code Examples

2. Send MIME Message

POST /v1/messages.mime

Headers

Response

Code Examples

3. Retrieve Email

GET /v1/getmessage/{id}

Response

Code Examples

4. Get Email Status

GET /v1/getstatus/{id}

Response

Code Examples

5. Cancel Unsent Email

GET /v1/cancelemail/{id}

Responses

Code Examples