advanced email templates

This post is directed at the developer who wants to get the most out of SparkPost’s email template capabilities. It is assumed you are comfortable with reading JSON content and following basic programming flow. As terms that maybe new to you are introduced like RFC 5322, the text is linked to its source reference. With that out of the way, let’s jump right in.

SparkPost’s template and transmission capabilities make sending emails straight forward. Those capabilities provide an abstraction for text and HTML content which means most times there is no need to directly encode the raw email format which is defined in RFC 5322 formerly known as (RFC 822). But sometimes you may want to create more complex messages that have other Multipurpose Internet Mail Extensions (MIME) parts that are not directly exposed via the SparkPost’s RESTful interface.

Simplified Email Composition

First, let’s review a sunny day scenario for sending an email. Use the transmission endpoint to provide the text and HTML content. Behind the scenes, SparkPost takes care of composing a valid RFC 5322 email. SparkPost will insert substitution variables from substitution_data into the text and HTML content. This is a powerful way to generate custom content for each recipient in a common template.

Here is an example transmission with HTML and text content with substitution_data.

{
  "options": {
    "open_tracking": true,
    "click_tracking": true
  },
  "campaign_id": "christmas_campaign",
  "return_path": "bounces-christmas-campaign@domain.com",
  "metadata": {
    "user_type": "students"
  },
  "substitution_data": {
    "sender": "Big Store Team"
  },
  "recipients": [
    {
      "return_path": "123@bounces.domain.com",
      "address": {
        "email": "wilma@domain.com",
        "name": "Wilma Flintstone"
      },
      "tags": [
        "greeting",
        "prehistoric",
        "fred",
        "flintstone"
      ],
      "metadata": {
        "place": "Bedrock"
      },
      "substitution_data": {
        "customer_type": "Platinum"
      }
    }
  ],
  "content": {
    "from": {
      "name": "Fred Flintstone",
      "email": "fred@domain.com"
    },
    "subject": "Big Christmas savings!",
    "reply_to": "Christmas Sales <sales@domain.com>",
    "headers": {
      "X-Customer-Campaign-ID": "christmas_campaign"
    },
    "text": "Hi {{address.name}} \nSave big this Christmas in your area {{place}}! \nClick http://www.mysite.com and get huge discount\n Hurry, this offer is only to {{user_type}}\n {{sender}}",
    "html": "<p>Hi {{address.name}} \nSave big this Christmas in your area {{place}}! \nClick http://www.mysite.com and get huge discount\n</p><p>Hurry, this offer is only to {{user_type}}\n</p><p>{{sender}}</p>"
  }
}

 

Substitute Arrays of Data 

Many folks realize that SparkPost’s transmission and template endpoints can do simple content substitution in email headers and email bodies. But many overlook the ability to provide conditional content or arrays of data that can be substituted as well. You can also provide unique content per recipient. In this example we send an array of unique links to each recipient.

This is accomplished by providing a JSON array of data that will be populated into the email body. Once the data is provided SparkPost will use logic in the template to populate it.

In this example SparkPost will look for substitution data called “files_html” and do a “for each” on each element in the array. It will create a row with the value of “file” in the “files_html” element. Note the triple curly around “loop_var.file“. This is because each element of the array contains HTML and we need to tell the server to use it as is and not escape it. The text part will be a simple text label and the URL to the file.

<table>
    {{each files_html}} 
         <tr><td> {{{loop_var.file}}} </td></tr>
    {{ end }}
</table>

Here is the completed working example:
{
    "recipients": [
        {
            "address": {
                "email": "recipient1@domain.com"
            },
            "substitution_data": {
                "files_html": [
                    {
                        "file": "<a href=\"http://domain.com/file1a.txt\">File 1a Description</a>"
                    },
                    {
                        "file": "<a href=\"http://domain.com/file2a.txt\">File 2a Description</a>"
                    }
                ],
                "files_plain": [
                    {
                        "file": "File 1a -- http://domain.com/file1a.txt"
                    },
                    {
                        "file": "File 2a -- http://domain.com/file2a.txt"
                    }
                ]
            }
        },
        {
            "address": {
                "email": "recipient2@domain.com"
            },
            "substitution_data": {
                "files_html": [
                    {
                        "file": "<a href=\"http://domain.com/file1b.txt\">File 1b Description</a>"
                    },
                    {
                        "file": "<a href=\"http://domain.com/file2b.txt\">File 2b Description</a>"
                    }
                ],
                "files_plain": [
                    {
                        "file": "File 1b -- http://domain.com/file1b.txt"
                    },
                    {
                        "file": "File 2b -- http://domain.com/file2b.txt"
                    }
                ]
            }
        }
    ],
    "return_path": "chris@test.domain.com",
    "content": {
        "from": {
            "name": "chris@test.domain.com",
            "email": "chris@test.domain.com"
        },
        "html": "<b>Your Files:</b><br>\n<table>\n{{each files_html}}    <tr><td> {{{loop_var.file}}} </td></tr>\n{{ end }} </table>\n\n",
        "text": "Your Files:\n{{each files_plain}} {{loop_var.file}} \n{{ end }} \n\n\n\n",
        "subject": "Sending with SparkPost is Fun"
    }
}

Pro Tip: In your code it is advisable to keep the view markup separate from the data but the goal here was to keep the example as simple and easy to follow as possible so we created two arrays. One array is for HTML part and the other is for the Text part. In production use it would be common to have one set of data and write the logic in the template code.

Attachments in Transmission Capabilities

The transmission endpoint also provides an abstraction for sending attachments. Below you will see attachments are specified in the content.attachments array where each object in the array describes an individual attachment item. Just as before SparkPost will take care of encoding text, HTML, substitutions and iterating through the attachment array to encode a properly formed email message.

Best practices dictate that sending attachments is best avoided unless explicitly required as part of your service.

name type
type The MIME type of the attachment
name The filename of the attachment
data Base64 encoded file data

This is what an attachment looks like inside transmission content stanza:

"content":{
    "attachments":[
        {
            "type":"audio/mp3",
            "name":"voicemail.mp3",
            "data":"TVAzIERhdGEK"
        }
    ]
}

You can also send “inline images” in a transmission. These are very similar to attachments and are specified in the content.inline_images array where each of the inline_image objects are similar to the attachment object shown above.

Attachments in Templates

Now that we have the proper background for sending attachments with the transmission endpoint let’s take a look at how to do this with templates. At the time of this writing, there is no attachments abstraction like you find for inline transmissions. One might conclude that templates can’t be created with attachments. You would be partially correct but there is a work around, although you will no longer be isolated from the RFC 5322 format.

You can accomplish attachments in templates by encoding RFC 5322 content yourself which includes the attachments. The good news is you won’t lose the ability to still use Substitution Data in your email headers, HTML and text parts. Be aware that this type of template limits the substitutions to the headers and the first HTML and first text part.

Here is an example of how it is done.

RFC822 Email

Create your RFC 5322 email with the substitution data you want. I created this one in my mail client and sent it to myself. Once I received it I copied the source and replace the fields I want to dynamically substitute.

MIME-Version: 1.0
Reply-To: {{replyto}}
Subject: {{subject}}
From: {{from}}
To: {{address.email}}
Content-Type: multipart/mixed; boundary=001a113c48b0b89d92052d3051da
 
--001a113c48b0b89d92052d3051da
Content-Type: multipart/alternative; boundary=001a113c48b0b89d89052d3051d8
 
--001a113c48b0b89d89052d3051d8
Content-Type: text/plain; charset=UTF-8
 
Email with a *text attachment*.
 
{{body2}}
 
--001a113c48b0b89d89052d3051d8
Content-Type: text/html; charset=UTF-8
 
<div dir="ltr"><div>Email with a <i>text attachment</i>.</div>
 
{{body1}}
</div>
 
--001a113c48b0b89d89052d3051d8--
--001a113c48b0b89d92052d3051da
Content-Type: text/plain; charset=US-ASCII; name="myfile.txt"
Content-Disposition: attachment; filename="myfile.txt"
Content-Transfer-Encoding: base64
X-Attachment-Id: f_ild455ce0
 
VGhpcyBpcyBteSBzaW1wbGUgdGV4dCBmaWxlLgo=
--001a113c48b0b89d92052d3051da--

The last MIME part in this message you will see Content-Disposition: attachment; filename=myfile.txt”. That is where the name of the file is defined. Your attachment content will most certainly be much more complex but this example is trying to keep it simple.

Stored Template

Once you have a valid RFC 5322 email store it using the email_rfc822 form of the template endpoint instead of using text and HTML fields. Here is an example of what the content looks like for that message:

{
    "content": {
        "email_rfc822": "MIME-Version: 1.0\nReply-To: {{replyto}}\nSubject: {{subject}}\nFrom: {{from}}\nTo: {{address.email}}\nContent-Type: multipart/mixed; boundary=001a113c48b0b89d92052d3051da\n\n--001a113c48b0b89d92052d3051da\nContent-Type: multipart/alternative; boundary=001a113c48b0b89d89052d3051d8\n\n--001a113c48b0b89d89052d3051d8\nContent-Type: text/plain; charset=UTF-8\n\nEmail with a *text attachment*.\n\n{{body2}}\n\n--001a113c48b0b89d89052d3051d8\nContent-Type: text/html; charset=UTF-8\n\n<div dir=\"ltr\"><div>Email with a <i>text attachment</i>.</div>\n\n{{body1}}\n</div>\n\n--001a113c48b0b89d89052d3051d8--\n--001a113c48b0b89d92052d3051da\nContent-Type: text/plain; charset=US-ASCII; name=\"myfile.txt\"\nContent-Disposition: attachment; filename=\"myfile.txt\"\nContent-Transfer-Encoding: base64\nX-Attachment-Id: f_ild455ce0\n\nVGhpcyBpcyBteSBzaW1wbGUgdGV4dCBmaWxlLgo=\n--001a113c48b0b89d92052d3051da--"
    },
    "name": "_TMP_TEMPLATE_TEST"
}

When the request completes, SparkPost will respond with a unique identifier for your new template. For example xxxxxxx.

Sending the Template

The good news is that creating the RFC 5322 content was the hard part. From here on out sending that template with SparkPost is exactly the same as sending any other template.

Here is how we send that template and populate the substitution data:

{
    "campaign_id": "MyCampaign",
    "return_path": "myReturnPath@yourdomain.com",
    "substitution_data": {
        "replyto": "myReplyToh@yourdomain.com",
        "from": "MyFrom@yourdomain.com",
        "subject":"my subject",
        "body1": "Extra content for the HTML part",
        "body2": "Extra content for the text part"
    },
    "recipients": [
        {
            "substitution_data": {},
            "address": {
                "email": "test1@domain.com",
                "name": "test1"
            }
        }
    ],
    "content": {
        "template_id": "xxxxxxx",
        "use_draft_template":true
    }
}

Templates from a Mail Client’s API

If you are using a programming language that has a library for composing an email, you can use that to programmatically create the template or even send the message inline. Here is an example of using JavaMail to do that very thing through SparkPost’s transmission endpoint. This method should be easily translated to PHP or your language of choice.

/**
 * This demonstration of using JavaMail MIME message with the SparkPosts RESTful interface
 */
public class App extends SparkPostBaseApp {
 
    public static void main(String[] args) throws Exception {
        Logger.getRootLogger().setLevel(Level.DEBUG);
         
        App app = new App();
        app.runApp();
    }
 
    private void runApp() throws Exception {
 
        Message message = createMultipartMessage();
 
        // Convert JavaMail message into a string for transmission
        String rfc822Content = getMessageAsString(message);
         
        // Add in a TO and a From field that will be populated from SparkPost substitution data
        rfc822Content = "To: {{address.email}}\r\nFrom: {{from}}\r\n" + rfc822Content;
 
        // Loads an email to send from the file system
        String fromAddress = getFromAddress();
        String[] recipients = getTestRecipients();
 
        sendEmail(fromAddress, recipients, rfc822Content);
 
    }
 
    private void sendEmail(String from, String[] recipients, String email) throws SparkPostException, IOException {
        Client sparkpostClient = newConfiguredClient();
 
        TransmissionWithRecipientArray transmission = new TransmissionWithRecipientArray();
 
        // Populate Recipients
        List<RecipientAttributes> recipientArray = new ArrayList<RecipientAttributes>();
        for (String recipient : recipients) {
            RecipientAttributes recipientAttribs = new RecipientAttributes();
            recipientAttribs.setAddress(new AddressAttributes(recipient));
            recipientArray.add(recipientAttribs);
        }
        transmission.setRecipientArray(recipientArray);
 
        transmission.setReturnPath(from);
 
        // Populate Substitution Data
        Map<String, String> substitutionData = new HashMap<String, String>();
        substitutionData.put("from", from);
         
        // SparkPost will set fields in HTML and/or Plain parts with the value here
        // See: https://developers.sparkpost.com/api/#/introduction/substitutions-reference
        substitutionData.put("name", "Your Name Here");
         
        transmission.setSubstitutionData(substitutionData);
 
        // Populate Email Body
        TemplateContentAttributes contentAttributes = new TemplateContentAttributes();
        contentAttributes.setEmailRFC822(email);
        transmission.setContentAttributes(contentAttributes);
 
        // Send the Email
        RestConnection connection = new RestConnection(sparkpostClient, getEndPoint());
 
        Response response = ResourceTransmissions.create(connection, 0, transmission);
        if (response.getResponseCode() == 200) {
            // Message successfully sent
            System.out.println("Transmission Response: " + response);
        } else {
            // An error occurred
            System.err.println("TRANSMISSION ERROR: " + response);
        }
    }
 
    /**
     * Builds an email with a text, HTML, and attachment part
     *
     * @return a JavaMail message
     * @throws MessagingException
     */
    private Message createMultipartMessage() throws MessagingException {
        Properties props = new Properties();
        // This is not used but we have to set it for JavaMail to create the
        // message
        props.put("mail.smtp.host", "none");
 
        Session session = Session.getDefaultInstance(props, null);
        Message message = new MimeMessage(session);
 
        message.setSubject("A multipart MIME message demo");
         
        Multipart multiPart = new MimeMultipart("alternative");
 
        // Create at text part
        MimeBodyPart textPart = new MimeBodyPart();
        textPart.setText("{{name}},\r\nplain text content", "utf-8");
 
        // Build HTML part of email
        MimeBodyPart htmlPart = new MimeBodyPart();
        htmlPart.setContent("<b>{{name}},<br><br>Our HTML content</b>", "text/html; charset=utf-8");
 
        // Put all the parts together
        multiPart.addBodyPart(textPart);
        multiPart.addBodyPart(htmlPart);
        message.setContent(multiPart);
         
        // Add an attachment to email
        MimeBodyPart attachmentPart = new MimeBodyPart();
 
        String filename = "java_SparkPost_background.pdf";
        DataSource source = new FileDataSource(filename);
        attachmentPart.setDataHandler(new DataHandler(source));
        attachmentPart.setFileName(filename);
        multiPart.addBodyPart(attachmentPart);
         
        return message;
    }
 
    /**
     * Turn a JavaMail message into RFC822 content
     *
     * @param msg
     *            the message that will be converted
     * @return RFC822 content
     * @throws MessagingException
     * @throws IOException
     */
    private String getMessageAsString(Message msg) throws IOException, MessagingException {
        String content = "";
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        try {
            msg.writeTo(out);
            content = new String(out.toByteArray(), "UTF-8");
            return content;
 
        } catch (UnsupportedEncodingException e) {
            // This should never happen but if it does stop everything here
            throw new Throwable("UTF-8 not found! " + e.getMessage());
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
 
        // Fail
        return null;
    }
}

Conclusion

Now that you see how SparkPost can be used to send email of almost any complexity you may want to have a look at “SparkPost Supports Sending Email on Apple Watch” or have a look at the substitution syntax to see how it can be used with “if then else”, “expressions in conditionals” or “array Iteration” right inside your template or transmission content.

This blog post was inspired by a question from one our of our fantastic community members who went on to write the SparkPost C Sharp library. If you want to get deeper with SparkPost, I encourage you to join the conversation in the SparkPost Community Slack Channel. You can also connect with us through the SparkPost development hub and on Twitter.

-Chris

If you liked this post, be sure to check out Automatic CSS Inlining with SparkPost