Send Email

Send an email using the API.

Pre-requisites

  • All authorized users can use this endpoint.

URI

To use this endpoint you send a POST request to:

  • /api/email/send-email

Request Headers

The following request headers must be included in your request:

FieldDescription
Authorization Please see the Authorization guide for more information on building the Authorization header.
x-mc-req-id

A randomly generated GUID, for example,

8578FCFC-A305-4D9A-99CB-F4D5ECEFE297
x-mc-app-id The Application ID provided with your Registered API Application.
x-mc-date

The current date and time in the following format, for example,

Tue, 24 Nov 2015 12:50:11 UTC

Request Body

{
 "data": [
  {
   "to": [
    {
     "emailAddress": "String", 
     "displayableName": "String"
    }
   ], 
   "from": {
    "emailAddress": "String", 
    "displayableName": "String"
   }, 
   "attachments": [
    {
     "size": 1000, 
     "id": "String", 
     "filename": "String"
    }
   ], 
   "htmlBody": {
    "content": "String", 
    "id": "String"
   }, 
   "cc": [
    {
     "emailAddress": "String", 
     "displayableName": "String"
    }
   ], 
   "plainBody": {
    "content": "String", 
    "id": "String"
   }, 
   "subject": "String", 
   "extraHeaders": [
    {
     "name": "String", 
     "value": "String"
    }
   ], 
   "bcc": [
    {
     "emailAddress": "String", 
     "displayableName": "String"
    }
   ]
  }
 ]
}
data
FieldTypeRequiredDescription
from Sender Object Optional An object describing the sender of the message. If not included, the details of the authorized user are used.
to Array of Recipient Objects Required An array of recipient objects describing the "to" recipient(s) of the message.
cc Array of Recipient Objects Optional An array of recipient objects describing the "cc" recipient(s) of the message.
bcc Array of Recipient Objects Optional An array of recipient objects describing the "bcc" recipient(s) of the message.
extraHeaders Array of Header Objects Optional An array of header objects describing any custom message headers to be included on the message.
subject String Required The message subject.
htmlBody Body Object Optional A body object describing the html body of the message.
plainBody Body Object Optional A body object describing the plain text body of the message.
attachments Optional Array of Attachment Objects An attachment object describing any attachments on the message.
Sender Object
FieldTypeRequiredDescription
displayableName String Required The display name to set for the sender of the message.
emailAddress String Required The email address to set for the sender of the message.
Recipient Object
FieldTypeRequiredDescription
displayableName String Required The display name to set for the recipient of the message.
emailAddress String Required The email address to set for the recipient of the message.
Header object
FieldTypeRequiredDescription
name String Required The name of the custom header to add to the message.
  String Required The value of the custom header to add to the message.
Body Object

When setting the message body in a request you can use either the "id" or "content" parameters. Do not use both

Use the "content" parameter for short messages where the total content length of the request body is less than 2048. 2048 is the maximum content length allowed by the API function.

Recommended: If you want to send a longer message body and for a more consistent experience, use the "id" parameter to set the message body to a file that has previously been uploaded to Mimecast using the /api/file/file-upload function.

FieldTypeRequiredDescription
id String Optional The Mimecast ID of a body part that has been previously uploaded to Mimecast using the /api/file/file-upload function.
content String Optional The content of the message body as a string.
Attachment Object
FieldTypeRequiredDescription
filename String Optional The file name to set for the attachment. If not set the API will automatically set the file name to "Mail Attachment" without a file extension.
id String Required The Mimecast ID of a file that has been previously uploaded to Mimecast using the /api/file/file-upload function.
  Number Required The size of the message attachment.

Response

{
 "fail": [], 
 "meta": {
  "status": 200
 }, 
 "data": [
  {
   "messageId": "String", 
   "messageDateHeader": "String"
  }
 ]
}
meta object
FieldTypeDescription
status Number The function level status of the request.
data
FieldTypeDescription
messageDateHeader String The date that the message was sent via the API.
messageId String The internet message id that the API automatically generates for the message.

Sample Code

Sample code is provided to demonstrate how to use the API and is not representative of a production application. To use the sample code; complete the required variables as described, populate the desired values in the request body, and execute in your favorite IDE.  Please see the Global Base URL's page to find the correct base URL to use for your account.

POST {base_url}/api/email/send-email
Authorization: MC {accesskKey}:{Base64 encoded signed Data To Sign}
x-mc-date: {dateTime}
x-mc-req-id: {unique id}
x-mc-app-id: {applicationId}
Content-Type: application/json
Accept: application/json


{
  "data":[
    {
        "from": {
                "displayableName": "String",
                "emailAddress": "String"
            },
        "to": [
            {
                "displayableName": "String",
                "emailAddress": "String"
            }
        ],
        "cc": [
            {
                "displayableName": "String",
                "emailAddress": "String"
            }
        ],
        "bcc": [
            {
                "displayableName": "String",
                "emailAddress": "String"
            }
        ],
        "extraHeaders": [
            {
                "name": "String",
                "value": "String"
            }
        ],
        "subject": "String",
        "htmlBody": {
            "id": "String",
            "content": "String"
        },
        "plainBody": {
            "id": "String",
            "content": "String"
        },
        "attachments": [
            {
                "filename": "String",
                "id": "String",
                "size": 1000
            }
        ]
    }
  ]
}
import base64
import hashlib
import hmac
import uuid
import datetime
import requests

# Setup required variables
base_url = "https://xx-api.mimecast.com"
uri = "/api/email/send-email"
url = base_url + uri
access_key = "YOUR ACCESS KEY"
secret_key = "YOUR SECRET KEY"
app_id = "YOUR APPLICATION ID"
app_key = "YOUR APPLICATION KEY"

# Generate request header values
request_id = str(uuid.uuid4())
hdr_date = datetime.datetime.utcnow().strftime("%a, %d %b %Y %H:%M:%S") + " UTC"

# Create the HMAC SHA1 of the Base64 decoded secret key for the Authorization header
hmac_sha1 = hmac.new(secret_key.decode("base64"), ':'.join([hdr_date, request_id, uri, app_key]),
                  digestmod=hashlib.sha1).digest()

# Use the HMAC SHA1 value to sign the hdrDate + ":" requestId + ":" + URI + ":" + appkey
sig = base64.encodeString(hmac_sha1).rstrip()

# Create request headers
headers = {
    'Authorization': 'MC ' + access_key + ':' + sig,
    'x-mc-app-id': app_id,
    'x-mc-date': hdr_date,
    'x-mc-req-id': request_id,
    'Content-Type': 'application/json'
}

payload = {
        'data': [
            {
                'from': {
                    'displayableName': 'String',
                    'emailAddress': 'String'
                },
                'to': [
                    {
                        'displayableName': 'String',
                        'emailAddress': 'String'
                    }
                ],
                'cc': [
                    {
                        'displayableName': 'String',
                        'emailAddress': 'String'
                    }
                ],
                'bcc': [
                    {
                        'displayableName': 'String',
                        'emailAddress': 'String'
                    }
                ],
                'extraHeaders': [
                    {
                        'name': 'String',
                        'value': 'String'
                    }
                ],
                'subject': 'String',
                'htmlBody': {
                    'id': 'String',
                    'content': 'String'
                },
                'plainBody': {
                    'id': 'String',
                    'content': 'String'
                },
                'attachments': [
                    {
                        'filename': 'String',
                        'id': 'String',
                        'size': 1000
                    }
                ]
            }
        ]
    }

r = requests.post(url=url, headers=headers, data=str(payload))

print r.text
static void Main(String[] args)
        {
            //Setup required variables
            String baseUrl = "https://xx-api.mimecast.com";
            String uri = "/api/email/send-email";
            String accessKey = "YOUR ACCESS KEY";
            String secretKey = "YOUR SECRET KEY";
            String appId = "YOUR APPLICATION ID";
            String appKey = "YOUR APPLICATION KEY";

            //Generate request header values
            String hdrDate = System.DateTime.Now.ToUniversalTime().ToString("R");
            String requestId = System.Guid.NewGuid().ToString();

            //Create the HMAC SHA1 of the Base64 decoded secret key for the Authorization header
            System.Security.Cryptography.HMAC h = new System.Security.Cryptography.HMACSHA1(System.Convert.FromBase64String(secretKey));

            //Use the HMAC SHA1 value to sign the hdrDate + ":" requestId + ":" + URI + ":" + appkey
            byte[] hash = h.ComputeHash(System.Text.Encoding.Default.GetBytes(hdrDate + ":" + requestId + ":" + uri + ":" + appKey));

            //Build the signature to be included in the Authorization header in your request
            String signature = "MC " + accessKey + ":" + System.Convert.ToBase64String(hash);

            //Build Request
            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(baseUrl + uri);
            request.Method = "POST";
            request.ContentType = "application/json";

            //Add Headers
            request.Headers[System.Net.HttpRequestHeader.Authorization] = signature;
            request.Headers.Add("x-mc-date", hdrDate);
            request.Headers.Add("x-mc-req-id", requestId);
            request.Headers.Add("x-mc-app-id", appId);

            //Add request body
            //Create and write data to stream
            String postData = @"{
                    ""data"": [
                        {
                            ""from"": {
                                ""displayableName"": ""String"",
                                ""emailAddress"": ""String""
                            },
                            ""to"": [
                                {
                                    ""displayableName"": ""String"",
                                    ""emailAddress"": ""String""
                                }
                            ],
                            ""cc"": [
                                {
                                    ""displayableName"": ""String"",
                                    ""emailAddress"": ""String""
                                }
                            ],
                            ""bcc"": [
                                {
                                    ""displayableName"": ""String"",
                                    ""emailAddress"": ""String""
                                }
                            ],
                            ""extraHeaders"": [
                                {
                                    ""name"": ""String"",
                                    ""value"": ""String""
                                }
                            ],
                            ""subject"": ""String"",
                            ""htmlBody"": {
                                ""id"": ""String"",
                                ""content"": ""String""
                            },
                            ""plainBody"": {
                                ""id"": ""String"",
                                ""content"": ""String""
                            },
                            ""attachments"": [
                                {
                                    ""filename"": ""String"",
                                    ""id"": ""String"",
                                    ""size"": 1000
                                }
                            ]
                        }
                    ]
                }";

            byte[] payload = System.Text.Encoding.UTF8.GetBytes(postData);

            System.IO.Stream stream = request.GetRequestStream();
            stream.Write(payload, 0, payload.Length);
            stream.Close();

            //Send Request
            System.Net.HttpWebResponse response = (System.Net.HttpWebResponse)request.GetResponse();

            //Output response to console
            System.IO.StreamReader reader = new System.IO.StreamReader(response.GetResponseStream());
            String responseBody = "";
            String temp = null;
            while ((temp = reader.ReadLine()) != null)
            {
                responseBody += temp;
            };
            System.Console.WriteLine(responseBody);
            System.Console.ReadLine();
        }
#Setup required variables
$baseUrl = "https://xx-api.mimecast.com"
$uri = "/api/email/send-email"
$url = $baseUrl + $uri
$accessKey = "YOUR ACCESS KEY"
$secretKey = "YOUR SECRET KEY"
$appId = "YOUR APPLICATION ID"
$appKey = "YOUR APPLICATION KEY"

#Generate request header values
$hdrDate = (Get-Date).ToUniversalTime().ToString("ddd, dd MMM yyyy HH:mm:ss UTC")
$requestId = [guid]::NewGuid().guid

#Create the HMAC SHA1 of the Base64 decoded secret key for the Authorization header
$sha = New-Object System.Security.Cryptography.HMACSHA1
$sha.key = [Convert]::FromBase64String($secretKey)
$sig = $sha.ComputeHash([Text.Encoding]::UTF8.GetBytes($hdrDate + ":" + $requestId + ":" + $uri + ":" + $appKey))
$sig = [Convert]::ToBase64String($sig)

#Create Headers
$headers = @{"Authorization" = "MC " + $accessKey + ":" + $sig;
                "x-mc-date" = $hdrDate;
                "x-mc-app-id" = $appId;
                "x-mc-req-id" = $requestId;
                "Content-Type" = "application/json"}

#Create post body
$postBody = "{
                    ""data"": [
                        {
                            ""from"": {
                                ""displayableName"": ""String"",
                                ""emailAddress"": ""String""
                            },
                            ""to"": [
                                {
                                    ""displayableName"": ""String"",
                                    ""emailAddress"": ""String""
                                }
                            ],
                            ""cc"": [
                                {
                                    ""displayableName"": ""String"",
                                    ""emailAddress"": ""String""
                                }
                            ],
                            ""bcc"": [
                                {
                                    ""displayableName"": ""String"",
                                    ""emailAddress"": ""String""
                                }
                            ],
                            ""extraHeaders"": [
                                {
                                    ""name"": ""String"",
                                    ""value"": ""String""
                                }
                            ],
                            ""subject"": ""String"",
                            ""htmlBody"": {
                                ""id"": ""String"",
                                ""content"": ""String""
                            },
                            ""plainBody"": {
                                ""id"": ""String"",
                                ""content"": ""String""
                            },
                            ""attachments"": [
                                {
                                    ""filename"": ""String"",
                                    ""id"": ""String"",
                                    ""size"": 1000
                                }
                            ]
                        }
                    ]
                }"

#Send Request
$response = Invoke-RestMethod -Method Post -Headers $headers -Body $postBody -Uri $url

#Print the response
$response
public static void main(String[] args) throws java.io.IOException, java.security.NoSuchAlgorithmException, java.security.InvalidKeyException {

        //set up variables for request
        String baseUrl = "https://xx-api.mimecast.com";
        String uri = "/api/email/send-email";
        String url = "https://" + baseUrl + uri;
        String accessKey = "YOUR ACCESS KEY";
        String secretKey = "YOUR SECRET KEY";
        String appId = "YOUR APPLICATION ID";
        String appKey = "YOUR APPLICATION KEY";

        //create URL object
        java.net.URL obj = new java.net.URL(url);

        // set guid for x-mc-req-id header
        String guid = java.util.UUID.randomUUID().toString();

        // set date for x-mc-date header
        java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss z");
        sdf.setTimeZone(java.util.TimeZone.getTimeZone("UTC"));
        String date = sdf.format(new java.util.Date());

        //create signature for the Authorization header
        String dataToSign = date + ":" + guid + ":" + uri + ":" + appKey;
        String hmacSHA1 = "HmacSHA1";
        javax.crypto.spec.SecretKeySpec signingKey = new javax.crypto.spec.SecretKeySpec(org.apache.commons.codec.binary.Base64.decodeBase64(secretKey.getBytes()), hmacSHA1);
        javax.crypto.Mac mac = javax.crypto.Mac.getInstance(hmacSHA1);
        mac.init(signingKey);
        String sig = new String(org.apache.commons.codec.binary.Base64.encodeBase64(mac.doFinal(dataToSign.getBytes())));

        // create request object
        javax.net.ssl.HttpsURLConnection con = (javax.net.ssl.HttpsURLConnection) obj.openConnection();

        //set request type to POST
        con.setRequestMethod("POST");
        con.setDoOutput(true);

        //add reuqest headers
        con.setRequestProperty("Authorization", "MC " + accessKey + ":" + sig);
        con.setRequestProperty("x-mc-req-id", guid);
        con.setRequestProperty("x-mc-app-id", appId);
        con.setRequestProperty("x-mc-date", date);
        con.setRequestProperty("Content-Type", "application/json");
        con.setRequestProperty("Accept", "application/json");

        //Add post body to the request
        String postBody = "{\n" +
        " \"data\": [\n" +
        "       {\n" +
        "            \"from\": {\n" +
        "                \"displayableName\": \"String\",\n" +
        "                \"emailAddress\": \"String\"\n" +
        "            },\n" +
        "            \"to\": [\n" +
        "                {\n" +
        "                    \"displayableName\": \"String\",\n" +
        "                    \"emailAddress\": \"String\"\n" +
        "                }\n" +
        "            ],\n" +
        "            \"cc\": [\n" +
        "                {\n" +
        "                    \"displayableName\": \"String\",\n" +
        "                    \"emailAddress\": \"String\"\n" +
        "                }\n" +
        "            ],\n" +
        "            \"bcc\": [\n" +
        "                {\n" +
        "                    \"displayableName\": \"String\",\n" +
        "                    \"emailAddress\": \"String\"\n" +
        "                }\n" +
        "            ],\n" +
        "            \"extraHeaders\": [\n" +
        "                {\n" +
        "                    \"name\": \"String\",\n" +
        "                    \"value\": \"String\"\n" +
        "                }\n" +
        "            ],\n" +
        "            \"subject\": \"String\",\n" +
        "            \"htmlBody\": {\n" +
        "                \"id\": \"String\",\n" +
        "                \"content\": \"String\"\n" +
        "            },\n" +
        "            \"plainBody\": {\n" +
        "                \"id\": \"String\",\n" +
        "                \"content\": \"String\"\n" +
        "            },\n" +
        "            \"attachments\": [\n" +
        "                {\n" +
        "                    \"filename\": \"String\",\n" +
        "                    \"id\": \"String\",\n" +
        "                    \"size\": 1000\n" +
        "                }\n" +
        "            ]\n" +
        "     }\n" +
        " ]\n" +
        "}";
        java.io.OutputStream os = con.getOutputStream();
        os.write(postBody.getBytes("UTF-8"));
        os.close();

        //process response
        java.io.BufferedReader in = new java.io.BufferedReader(
                new java.io.InputStreamReader(con.getInputStream()));
        String inputLine;
        StringBuffer response = new StringBuffer();

        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

        //return result
        java.lang.System.out.println(response.toString());
    }