Mimecast

Find Held Messages

Description

This API endpoint can be used to get information about held messages, including the reason, hold level, sender and recipients. The ID can be used to act on a message using the Release Message or Reject Message API endpoints.

Pre-requisites

  • In order to successfully use this endpoint the logged in user must be a Mimecast administrator with at least the Account | Monitoring | Held | Read permission.

URI

To use this endpont you send a POST request to:

  • /api/gateway/find-held-messages

Request Headers

The following request headers must be included in your request:

Field Description
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": [
  {
   "admin": "true", 
   "start": "2015-11-16T14:49:18+0000", 
   "searchBy": {
    "fieldName": "String", 
    "value": "String"
   }, 
   "end": "2015-11-16T14:49:18+0000", 
   "filterBy": [
    {
     "fieldName": "String", 
     "value": "String"
    }
   ]
  }
 ]
}
data
Field Type Required Description
admin Boolean Optioneel Level of results to return. If false, only results for the currenlty authenticated user will be returned. If true, held messages for all recipients will be returned. The default value is false.
searchBy Object Optioneel Object data used to filter results
start Date String Optioneel The date and time of the earliest message to return, in the following format, 2011-12-03T10:15:30+0000
end Date String Optioneel The date and time of the latest message to return, in the following format, 2011-12-03T10:15:30+0000
filterBy Array Optioneel Filter options to narrow results
searchBy
Field Type Required Description
value String Optioneel The text used to filter results
fieldName String Optioneel Message fields to filter based on. Possible values are: all, subject, sender, recipient, reason_code
filterBy
Field Type Required Description
route String Optioneel Specify the route of emails to return. Possible values are: all, internal, outbound, inbound, external
heldGroup String Optioneel Specify the level of hold placed on messages to return. Possible values are: administrator, moderator, user, cluster
attachments Boolean Optioneel Specify if results should be held attachments (e.g. Attachment Management holds)

Response

{
 "fail": [], 
 "meta": {
  "status": 200
 }, 
 "data": [
  {
   "heldEmails": [
    {
     "status": "String", 
     "fromHdr": {
      "displayableName": "String", 
      "emailAddress": "String"
     }, 
     "heldSince": "2018-08-14T03:03:40+0000", 
     "attachments": "true", 
     "received": "2018-08-14T03:03:40+0000", 
     "route": "String", 
     "messageInfo": "String", 
     "policyInfo": "String", 
     "subject": "String", 
     "to": [
      {
       "displayableName": "String", 
       "emailAddress": "String"
      }
     ], 
     "fromEnv": {
      "displayableName": "String", 
      "emailAddress": "String"
     }, 
     "heldReason": "String", 
     "senderIP": "String", 
     "heldGroup": "String", 
     "id": "String", 
     "sent": "2018-08-14T03:03:40+0000", 
     "size": "Number"
    }
   ]
  }
 ]
}
meta object
Field Type Description
status Number The function level status of the request.
meta
Field Type Description
status Number The function level status of the request.
data
Field Type Description
heldEmails Array An array of held messages
heldEmails
Field Type Description
heldReason String The general reason for holding a message
heldGroup String The level of a message hold. Possible values are: administrator, moderator, user
heldSince Date String The date that the message was held
messageInfo String The name of the definition that held a message
policyInfo String The name of the policy that held a message
size Number The size of the message in bytes
id String The Mimecast secure ID of a message
status String The current held status of a message
fromEnv Object An EmailAddress object containing the envelope from information
fromHdr Object An EmailAddress object containing the header from information
to Array An array of EmailAddress recipeint objects
received Date String The date that the message was received by Mimecast
subject String The mesasge subject
senderIP String The IP address that delivered the message to Mimecast
attachments Boolean Returns true if the message contains attachments; otherwise returns false
route String The route of the held message. Possible values are: inbound, outbound, internal, external
sent Date String The date that the mesage was sent
EmailAddress
Field Type Description
emailAddress String An email address
displayableName String A display name, if available

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/gateway/find-held-messages
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":[
    {
        "data":[
            {
                "searchBy": {
                    "value": "String",
                    "fieldName": "String"
                },
                "start": "2015-11-16T14:49:18+0000",
                "admin": true,
                "end": "2015-11-16T14:49:18+0000",
                "filterBy": {
                    "value": "String",
                    "fieldName": "String"
                }
            }
        ]
    }
  ]
}
import base64
import hashlib
import hmac
import uuid
import datetime
import requests

# Setup required variables
base_url = "https://xx-api.mimecast.com"
uri = "/api/gateway/find-held-messages"
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': [
            {
                "searchBy": {
                    "value": "String",
                    "fieldName": "String"
                },
                "start": "2015-11-16T14:49:18+0000",
                "admin": true,
                "end": "2015-11-16T14:49:18+0000",
                "filterBy": {
                    "value": "String",
                    "fieldName": "String"
                }
            }
        ]
    }

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/gateway/find-held-messages";
            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"": [
                        {
                            ""searchBy"": {
                                ""value"": ""String"",
                                ""fieldName"": ""String""
                            },
                            ""start"": ""2015-11-16T14:49:18+0000"",
                            ""admin"": true,
                            ""end"": ""2015-11-16T14:49:18+0000"",
                            ""filterBy"": {
                                ""value"": ""String"",
                                ""fieldName"": ""String""
                            }
                        }
                    ]
                }";

            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/gateway/find-held-messages"
$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"": [
                        {
                            ""searchBy"": {
                                ""value"": ""String"",
                                ""fieldName"": ""String""
                            },
                            ""start"": ""2015-11-16T14:49:18+0000"",
                            ""admin"": true,
                            ""end"": ""2015-11-16T14:49:18+0000"",
                            ""filterBy"": {
                                ""value"": ""String"",
                                ""fieldName"": ""String""
                            }
                        }
                    ]
                }"

#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/gateway/find-held-messages";
        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" +
        "          \"searchBy\": {\n" +
        "               \"value\": \"String\"\n +
        "               \"fieldName\": \"String\"\n +
        "          }\n" +
        "          \"start\": \"2015-11-16T14:49:18+0000\"\n +
        "          \"admin\": true\n +
        "          \"end\": \"2015-11-16T14:49:18+0000\"\n +
        "          \"filterBy\": {\n" +
        "               \"value\": \"String\"\n +
        "               \"fieldName\": \"String\"\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());
    }