> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://mailchimp.com/developer/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://mailchimp.com/developer/_mcp/server.

# Send a raw message

POST https://mandrillapp.com/api/1.4/messages/send-raw
Content-Type: application/json

Send a raw MIME document for a message, and send it exactly as if it were sent through Mandrill's SMTP servers.

Reference: https://mailchimp.com/developer/transactional/api/messages/send-raw

## Request

### Body (application/json)

This endpoint expects a MessagesSendRawRequest.

- `key` (string, required) — A valid Mandrill API key
- `raw_message` (string, required) — the full MIME document of an email message
- `from_email` (string, optional, nullable) — optionally define the sender address - otherwise we'll use the address found in the provided headers
- `from_name` (string, optional, nullable) — optionally define the sender alias
- `to` (list of string, optional) — optionally define the recipient to receive the message - otherwise we'll use the To, Cc, and Bcc headers provided in the document
- `async` (boolean, optional, nullable) — enable a background sending mode that is optimized for bulk sending. In async mode, messages/send will immediately return a status of "queued" for every recipient. To handle rejections when sending in async mode, set up a webhook for the 'reject' event. Defaults to false for messages with no more than 10 recipients; messages with more than 10 recipients are always sent asynchronously, regardless of the value of async.
- `ip_pool` (string, optional) — the name of the dedicated ip pool that should be used to send the message. If you do not have any dedicated IPs, this parameter has no effect. If you specify a pool that does not exist, your default pool will be used instead.
- `send_at` (string, optional) — when this message should be sent as a UTC timestamp in YYYY-MM-DD HH:MM:SS format. If you specify a time in the past, the message will be sent immediately; for future dates, you're limited to one year from the date of scheduling.
- `return_path_domain` (string, optional, nullable) — a custom domain to use for the messages' return-path

## Response

### 200

Success

- `any`

## Errors

### 401 Unauthorized Error

Invalid or missing API key.

- `status` (string, required) — Status of the response, typically "error"
- `code` (enum, required) — Numeric error code
  - Allowed values: `401`
- `name` (enum, required) — Machine-friendly error name
  - Allowed values: `Invalid_Key`
- `message` (string, required) — Human-readable error message

### 402 Payment Required Error

A paid plan is required to use this feature.

- `status` (string, required) — Status of the response, typically "error"
- `code` (enum, required) — Numeric error code
  - Allowed values: `10`
- `name` (enum, required) — Machine-friendly error name
  - Allowed values: `PaymentRequired`
- `message` (string, required) — Human-readable error message

### 404 Not Found Error

Unknown subaccount

- `status` (string, required) — Status of the response, typically "error"
- `code` (integer, required) — Numeric error code
- `name` (string, required) — Machine-friendly error name
- `message` (string, required) — Human-readable error message

### 500 Internal Server Error

An unexpected internal server error occurred.

- `status` (string, required) — Status of the response, typically "error"
- `code` (integer, required) — Numeric error code
- `name` (string, required) — Machine-friendly error name
- `message` (string, required) — Human-readable error message

## Examples

**Request**

```json
{
  "key": "ONzNrsmbtNXoIKyfPmjnig",
  "raw_message": "string"
}
```

**Response**

```json
[
  {
    "_id": "string",
    "email": "recipient.email@example.com",
    "queued_reason": "attachments",
    "reject_reason": "hard-bounce",
    "status": "sent"
  }
]
```

**SDK Code**

```python
import requests

url = "https://mandrillapp.com/api/1.4/messages/send-raw"

payload = {
    "key": "ONzNrsmbtNXoIKyfPmjnig",
    "raw_message": "string"
}
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://mandrillapp.com/api/1.4/messages/send-raw';
const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: '{"key":"ONzNrsmbtNXoIKyfPmjnig","raw_message":"string"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://mandrillapp.com/api/1.4/messages/send-raw"

	payload := strings.NewReader("{\n  \"key\": \"ONzNrsmbtNXoIKyfPmjnig\",\n  \"raw_message\": \"string\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://mandrillapp.com/api/1.4/messages/send-raw")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"key\": \"ONzNrsmbtNXoIKyfPmjnig\",\n  \"raw_message\": \"string\"\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://mandrillapp.com/api/1.4/messages/send-raw")
  .header("Content-Type", "application/json")
  .body("{\n  \"key\": \"ONzNrsmbtNXoIKyfPmjnig\",\n  \"raw_message\": \"string\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://mandrillapp.com/api/1.4/messages/send-raw', [
  'body' => '{
  "key": "ONzNrsmbtNXoIKyfPmjnig",
  "raw_message": "string"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://mandrillapp.com/api/1.4/messages/send-raw");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"key\": \"ONzNrsmbtNXoIKyfPmjnig\",\n  \"raw_message\": \"string\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "key": "ONzNrsmbtNXoIKyfPmjnig",
  "raw_message": "string"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://mandrillapp.com/api/1.4/messages/send-raw")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```