Skip navigation
All Places > Marketo Whisperer: Implementation Tips > 2015 > December

Nothing reminds you to get up and write a blog post in the morning like seeing that the last several posts were all by very technical people!


Last week I was onsite with a client that is doing a kickoff with RCA. One of the sessions I presented to them was on best practices for how to set up Marketo to get the best results out of RCA. Here are some cliff notes of my main points:

  • First, make sure that you have every marketing activity that you do tracked in Marketo. Each marketing activity should correspond to a single Marketo program. Some of the activities people commonly overlook are:
    • Tradeshows and other events
    • Direct mail
    • Web forms
    • Online advertising
    • Mobile
    • SMS
  • When you are building programs, there are seven things to keep in mind:
    • Establish a good naming convention
    • Use program statuses and success
    • Assign lead acquisition to a program for basically every lead (You can set up placeholder programs for leads created in CRM and the API)
    • Add costs to programs and events
    • Define tags and custom channels
    • Set the analytics behavior per channel (I usually suggest making all non-operational channels Inclusive)
    • Define Interesting Moments for the Opportunity Influence Analyzer
  • Build out at least one revenue model for your funnel and make sure the majority of your database is assigned to and moving through the proper stages
  • Make sure you are using the required/recommended fields that RCA needs to work properly (even if it says SFDC, same thing for MSD):
    • Lead: Is Lead, Person Type, Updated, Is Employee, Updated At, Org Id, Lead Source, Acquisition Date, Acquisition Program, Created, Lead Owner First Name, Lead Owner Last Name, SFDC Created Date
    • Company: Company, SFDC is Deleted, Updated At
    • Opportunity: Created At, Updated At, Amount, Close Date, Is Closed, Is Won, Name, Probability, SFDC Created Date, Account Id
    • Opportunity Contact Role: Opportunity ID, Contact ID, Created At, Updated At, SFDC is Deleted
  • Sync over a selection of custom fields for use in RCA as dimensions and metrics
  • Create group field organizers to help you group values for a field in Model Performance Analysis
  • Make sure you have opportunity contact roles
  • Validate if you need to use Hybrid or Implicit Attribution settings
  • Make sure you are using a lead source type field correctly

This post originally appears here.


Last time, we took a look at triggering transactional emails from outside of Marketo.  This week we'll be looking at how to pass dynamic content to our emails via the Request Campaign API call.  Request Campaign not only allows the triggering of emails externally, but you can  also replace the content of My Tokens within an email.  My tokens are reusable content that can be customized at the program or marketing folder level.  These can also just exist as placeholders to be replaced through your request campaign call.  For instructions on configuring the smart campaign, see part one.

Building your Email

In order to customize our content, first we will need to configure a program and an email in Marketo.  To generate our custom content, we will need to create tokens inside of the program, and then place them into the email that we're going to be sending.  For simplicity's sake, we'll be using just one token in this example, but you can replace any number of tokens in an email, in the From Email, From Name, Reply-to or any piece of content in the email.  So let's create one token Rich Text for replacement and call it "bodyReplacement".  Rich Text allows us to replace any content in the token with arbitrary HTML that we want to input. create a new token

Tokens can't be saved while empty, so go ahead and insert some placeholder text here.  Now we need to insert our token into the email:

add token to email

This token will now be accessible for replacement through a Request Campaign call.  This token can be as simple as a single line of text which needs to be replaced on a per-email basis, or can include almost the entire layout of the email.

The Code

In previous posts, we've looked at authenticating and retrieving lead records, and then sending an email to those leads.  We'll be expanding on the code from last week to pass in customized tokens to our request campaign call.

package dev.marketo.blog_request_campaign;  import com.eclipsesource.json.JsonArray;  public class App { public static void main( String[] args ) { //Create an instance of Auth so that we can authenticate with our Marketo instance Auth auth = new Auth("Client ID - CHANGE ME", "Client Secret - CHANGE ME", "Host - CHANGE ME");  //Create and parameterize an instance of Leads Leads leadsRequest = new Leads(auth).setFilterType("email").addFilterValue("");  //get the inner results array of the response JsonArray leadsResult = leadsRequest.getData().get("result").asArray();  //get the id of the record indexed at 0 int lead = leadsResult.get(0).asObject().get("id").asInt();  //Set the ID of our campaign from Marketo int campaignId = 1578; RequestCampaign rc = new RequestCampaign(auth, campaignId).addLead(lead);  //Create the content of the token here, and add it to the request String bodyReplacement = "<div class=\"replacedContent\"><p>This content has been replaced</p></div>"; rc.addToken("{{my.bodyReplacement}}", bodyReplacement); rc.postData(); } } 

If the code looks familiar, that's because it only has two additional lines from the main method in the previous post.  This time we're creating the content of our token in the bodyReplacement variable and then using the addToken method to add it to the request.  addToken takes a key and a value and then creates a JsonObject representation and adds it to the internal tokens array.  This is then serialized during the postData method and creates a body that looks like this:

{"input":{"leads":[{"id":1}],"tokens":[{"name":"{{my.bodyReplacement}}","value":"<div class=\"replacedContent\"><p>This content has been replaced</p></div>"}]}}

Combined, our console output looks like this:

Token is empty or expired. Trying new authentication Trying to authenticate with ... Got Authentication Response: {"access_token":"19d51b9a-ff60-4222-bbd5-be8b206f1d40:st","token_type":"bearer","expires_in":3565,"scope":""} Executing RequestCampaign call Endpoint: .../rest/v1/campaigns/1578/trigger.json?access_token=19d51b9a-ff60-4222-bbd5-be8b206f1d40:st Request Body: {"input":{"leads":[{"id":1}],"tokens":[{"name":"{{my.bodyReplacement}}","value":"&lt;div class=\"replacedContent\"&gt;&lt;p&gt;This content has been replaced&lt;/p&gt;&lt;/div&gt;"}]}} Result: {"requestId":"1e8d#14eadc5143d","result":[{"id":1578}],"success":true} 

Wrapping Up

This method is extensible in a multitude of ways, changing content in emails within individual layout sections, or outside emails, allowing custom values to be passed into tasks or interesting moments.  Anywhere a my token can be used from within a program can be customized using this method.  Similar functionality is also available with the Schedule Campaign call which will allow you to process tokens across an entire batch campaign.  These can't be customized on a per lead basis, but are very useful for customizing content across a wide set of leads.

This post originally appears here.


A common use case for the Marketo API is to trigger the sending of transactional emails to specific records via the Request Campaign API call.  You can find an example covering this use case with the SOAP API here.  There are a few configuration requirements within Marketo in order to execute the required call with the Marketo REST API.

  • The recipient must have a record within Marketo
  • There needs to be a Transactional Email created and approved in your Marketo instance.
  • There needs to be an active trigger campaign with the Campaign is Requested, Source: Web Service API, that is set up to send the email

First create and approve your email.  If the email is truly transactional, you will likely need to set it to operational, but be sure that it legally qualifies as operational.  This is configured from with the Edit Screen under Email Actions > Email Settings:

Request Campaign - Email Settings

Request Campaign - Operational

Approve it and we’re ready to create our campaign:

RequestCampaign - Approve Draft

If you’re new to creating campaigns, check out the Create a New Smart Campaign article on  Once you’ve created your campaign, we need to go through these steps.  Configure your Smart List with the Campaign is Requested trigger: Request Campaign - Smart List

Now we need to configure the flow to point a Send Email step to our email: Request Campaign - Flow

Before activation, you’ll need to decide on some settings in the Schedule tab.  If this particular email should only ever be sent once to a given record, then leave the qualification settings as is.  If it’s required that they receive the email multiple times, though, you’ll want to adjust this to either every time or to one of the available cadences: Qualification Rules

Now we’re ready to activate:

Request Campaign - Schedule

Sending the API Calls

Note: In the Java examples below, we’ll be using the minimal-json package to handle JSON representations in our code.  You can read more about this project here:

The first part of sending a transactional email through the API is ensuring that a record with the corresponding email address exists in your Marketo instance and that we have access to its lead ID.  For the purposes of this post, we will assume that the email addresses are in Marketo already, and we only need to retrieve the ID of the record.  For this, we will be using the Get Multiple Leads by Filter Type call, and we will be reusing some of the Java code from the previous post on authenticating and retrieving lead data from Marketo. Let's take a look at our Main method for to request the campaign:

package dev.marketo.blog_request_campaign;  import com.eclipsesource.json.JsonArray;  public class App  {     public static void main( String[] args )     {          //Create an instance of Auth so that we can authenticate with our Marketo instance         Leads leadsRequest = new Leads(auth).setFilterType("email").addFilterValue("");          //Create and parameterize an instance of Leads         //Set your email filterValue appropriately         Leads leadsRequest = new Leads(auth).setFilterType("email").addFilterValue("");          //Get the inner results array of the response         JsonArray leadsResult = leadsRequest.getData().get("result").asArray();          //Get the id of the record indexed at 0         int lead = leadsResult.get(0).asObject().get("id").asInt();          //Set the ID of your campaign from Marketo         int campaignId = 0;         RequestCampaign rc = new RequestCampaign(auth, campaignId).addLead(lead);          //Send the request to Marketo         rc.postData();     } }

To get to these results from the JsonObject response of leadsRequest, we’ll need to write some code .  To retrieve the first result in the Array, we need to extract the Array from the JsonObject and get the object indexed at 0:


JsonArray leadsResult = leadsRequest.getData().get("result").asArray(); int leadId = leadsResult.get(0).asObject().get("id").asInt();


From here now all we need to do is the Request Campaign call.  For this, the required parameters are ID in the URL of the request, and an array of JSON objects containing one member, "id."  Let's take a look at the code for this:

package dev.marketo.blog_request_campaign; import; import; import; import; import; import; import; import java.util.ArrayList; import; import com.eclipsesource.json.JsonArray; import com.eclipsesource.json.JsonObject;  public class RequestCampaign {      private String endpoint;      private Auth auth;      public ArrayList leads = new ArrayList();      public ArrayList tokens = new ArrayList();            public RequestCampaign(Auth auth, int campaignId) {           this.auth = auth;           this.endpoint = this.auth.marketoInstance + "/rest/v1/campaigns/" + campaignId + "/trigger.json";      }      public RequestCampaign setLeads(ArrayList leads) {           this.leads = leads;           return this;      }      public RequestCampaign addLead(int lead){           leads.add(lead);           return this;      }      public RequestCampaign setTokens(ArrayList tokens) {           this.tokens = tokens;           return this;      }      public RequestCampaign addToken(String tokenKey, String val){           JsonObject jo = new JsonObject().add("name", tokenKey);           jo.add("value", val);           tokens.add(jo);           return this;      }      public JsonObject postData(){           JsonObject result = null;           try {                JsonObject requestBody = buildRequest(); //builds the Json Request Body                String s = endpoint + "?access_token=" + auth.getToken(); //takes the endpoint URL and appends the access_token parameter to authenticate                System.out.println("Executing RequestCampaign call\n" + "Endpoint: " + s + "\nRequest Body:\n"  + requestBody);                URL url = new URL(s);                 HttpsURLConnection urlConn = (HttpsURLConnection) url.openConnection(); //Return a URL connection and cast to HttpsURLConnection                urlConn.setRequestMethod("POST");                urlConn.setRequestProperty("Content-type", "application/json");             urlConn.setRequestProperty("accept", "text/json");             urlConn.setDoOutput(true);                OutputStreamWriter wr = new OutputStreamWriter(urlConn.getOutputStream());                wr.write(requestBody.toString());                wr.flush();                InputStream inStream = urlConn.getInputStream(); //get the inputStream from the URL connection                Reader reader = new InputStreamReader(inStream);                result = JsonObject.readFrom(reader); //Read from the stream into a JsonObject                System.out.println("Result:\n" + result);           } catch (MalformedURLException e) {                e.printStackTrace();           } catch (IOException e) {                e.printStackTrace();           }           return result;      }            private JsonObject buildRequest(){           JsonObject requestBody = new JsonObject(); //Create a new JsonObject for the Request Body           JsonObject input = new JsonObject();           JsonArray leadsArray = new JsonArray();           for (int lead : leads) {                JsonObject jo = new JsonObject().add("id", lead);                leadsArray.add(jo);           }           input.add("leads", leadsArray);           JsonArray tokensArray = new JsonArray();           for (JsonObject jo : tokens) {                tokensArray.add(jo);           }           input.add("tokens", tokensArray);           requestBody.add("input", input);           return requestBody;      }  }

This class has one constructor taking an Auth, and the Id of the campaign.  Leads are added to the object either by passing an ArrayList<Integer> containing the Ids of the records to setLeads, or by using addLead, which takes one integer and appends it to the existing ArrayList in the leads property.  To trigger the API call to pass the lead records to the campaign, postData needs to be called, which returns a JsonObject containing the response data from the request.  When request campaign is called, every lead passed to the call will be processed by the target trigger campaign in Marketo and be sent the email which was created previously. Congratulations, you've triggered an email through the Marketo REST API.  Keep an eye out for Part 2 where we'll look at dynamically customizing the content of an email through Request Campaign.

This post originally appears here


This guide will show you how to make your first call to the Marketo REST API in ten minutes.

We'll show you how to retrieve a single lead using the Get Lead by Id REST API endpoint. To do this, we will walk you through the authentication process to generate an access token, which you will use in making a GET request to Get Lead by Id. Then we'll provide you with the code to make the request that will return lead info formatted as JSON.

How to Generate an Authentication Token

A Custom Service in Marketo allows you to describe and define what data your application will have access to. You need to be logged in as a Marketo administrator to create a Custom Service and associate that service with a single API-Only user.

1. Navigate to the admin area of the Marketo application


2. Click on the Users & Roles node on the left panel


3. Create a new role


4. The next step is to create an API only user and associating it with the API role that you created in step 3. You can do so by checking the API-Only user checkbox at the time of user creation.


5. A Custom service is required to uniquely identify your client application. To create a custom application, go to the Admin->LaunchPoint screen and create a new service.


6. Choose "Custom" Service type, provide the Display Name, Description and the user email address created in step 4. We recommend using a descriptive Display Name that represents either the company or purpose of this Custom REST API Service.


7. Click on "View Details" link on the grid to get the Client Id and Client Secret.


Your client application will be able to use the Client Id and Client Secret to generate an access token.


8. Copy and paste your authentication token into a text editor. Your authentication token will look similar to the example below.


How to Determine Endpoint URL

In making a request to Marketo API, you will need to specify your Marketo instance in the endpoint URL. All requests to the Marketo REST API will follow the format below.

<REST API Endpoint URL>/rest/ 

The REST API Endpoint URL can be found within the Marketo Admin->Web Services panel.


Your Marketo endpoint URL structure should look similar to the example below.{id}.json 

How to Use Authentication Token to Call Get Lead by Id API

In the previous sections, we generated an authentication token and found the endpoint URL. We will now make a request to REST API endpoint called Get Lead by Id.

The easiest way to make your request to Marketo REST API is to paste the URL into your web browser's address bar. Follow the format below.


// Format http://<REST API Endpoint URL for your Marketo instance>/rest/v1/<API you are calling>?<access_token>  // Example 

If your call is successful, it will return JSON with the format below.

{ "requestId": "d82a#14e26755a9c", "result": [ { "id": 318581, "updatedAt": "2015-06-11T23:15:23Z", "lastName": "Doe", "email": "", "createdAt": "2015-03-17T00:18:40Z", "firstName": "John" } ], "success": true } 

If you are interested in learning more about the Marketo REST APIs, this is a good place to start.

* This article contains code used to implement custom integrations. Due to its customized nature, The Marketo Technical Support team is unable to troubleshoot custom work. Please do not attempt to implement the following code sample without appropriate technical experience, or access to an experienced developer.

This post originally appears here.


SoundCloud provides an incredible audio hosting platform, with rich analytics and functionality for everything from aspiring indie rock acts, to EDM artists at the top of the music industry, to storytelling podcasts.  Along with the incredible native functionality of the platform comes a world-class API program to move your data and track listening behavior.  This is especially useful for podcasters, and can allow you to correlate specific listening actions, like plays, pauses, and shares to specific content in the script and the audio.  Today we'll take a look at leveraging SoundCloud's widget API to send and track these activities in Marketo.  The pattern we'll be using may seem familiar if you've read our post on tracking YouTube video views.

First let's look at generating a Munchkin activity which will be recorded to a lead's activity log in Marketo.  At it's most basic, we make a call to Munchkin.munchkinFunction and pass "visitWebPage" as the first argument.  This will log a Visits Web Page activity with Marketo, and record any arbitrary URL and Query String data which we pass to the method.  The second argument accepts a JavaScript object with our data, which has two members, "url," and"params," both strings.  The url member corresponds to the Web Page of the activity in Marketo, while params corresponds to the Querystring.  For our purposes, we'll use the url as an identifier for SoundCloud related actions, "soundCloudInteraction," while params will contain additional data about the particular activity.  Here's the function we'll be using to track each action:

var trackActivity = function(action){           //set action param to be the string passed to the function           var qs = "action=" + action;           //use getCurrentSound callback to get the name of the current track           soundCloudMunchkin.widget.getCurrentSound(function(currentSound){                //add it to our querystring                qs = qs + "&sound=" + currentSound.title;                //use the getPosition callback to get the position of the track in ms                soundCloudMunchkin.widget.getPosition(function(position){                     //add it to the querystring                     qs = qs + "&position=" + position;                     //assemble our data object for the munchkin activity                     var dataObject = {                          "url": "soundCloudInteraction",                          "params": qs                     }                     //call the munchkinFunction to submit the activity                     Munchkin.munchkinFunction("visitWebPage", dataObject);                });           });                 }

Since the standard SoundCloud widget is embedded in an iframe, the widget uses post messages to communicate and callbacks need to be used to obtain data, as you can see with the currentSound and getPosition methods.

The SoundCloud widget API provides a set of JavaScript callbacks that we can use to respond to individual events in the player and submit these to Marketo.  The ones that we're interested are to what and how long the user listens, and interactions that they make with the player, so we're looking at the following events:

  • PLAY
  • SEEK

We'll also need to use the bind() method from the widget to add callbacks to each of these events.  Let's look at one example:

widget.bind(SC.Widget.Events.PLAY, function(){  soundCloudMunchkin.trackPlay();  });

This will make it so that whenever a track is played, we'll fire the trackPlay method to send an event to Marketo with data about the current track.  You can find the full script here:  the soundCloudMunchkin object has an init method, which accepts a SoundCloud widget object as it's only argument, which binds the tracking methods to the relevant callbacks, and will set up your widget to track activity down to Marketo.  Your page will need to have your Munchkin code loaded, as well as the SoundCloud API library.  You'll also need to initialize everything, in addition to embedding your actual SoundCloud widget:

window.onload=function(){      var iframe = document.getElementById(iframeId);      if(iframe) {         widget = SC.Widget(iframe);           soundCloudMunchkin.init(widget);      }; };

Check out a live demo here, and happy tracking!

John M

Leveraging RTP for EU e-Privacy

Posted by John M Employee Dec 17, 2015

In a previous blog post (Handling Cookies and Privacy in the EU )  I talked through a method for conditionally loading Munchkin based on location. The solution depended on a 3rd party to provide the location based lookup data. In the meantime, I've revised the solution to leverage our very own RTP product, because one of the things that RTP does very well is determine the location of an anonymous lead without storing any personally identifiable information (PII)


Screen Shot 2015-12-17 at 2.54.47 PM.png

The first step is to define a segment which will trigger on any visitor from the EU, the EU countries being Austria, Belgium, Bulgaria, Croatia, Republic ofCyprus, Czech Republic, Denmark, Estonia, Finland, France, Germany, Greece, Hungary, Ireland, Italy, Latvia, Lithuania, Luxembourg, Malta, Netherlands, Poland, Portugal, Romania, Slovakia,Slovenia, Spain, Sweden and the UK. (whew)

Screen Shot 2015-12-17 at 4.02.16 PM.png

So, once we have that, we have a segment to match, and we can leverage the RTP Javascript API. Now, assuming you have RTP installed peroperly on your site, you can trigger a callback function with a single line of code


rtp('get', 'visitor', examineVisitor);


In the examineVisitor function you can do things like

1. Parse out the response and see if the user matches your segment (in my case, #3861, which I get by hovering over the name in RTP)

2. If the user if from the EU, check for the existence of your Marketo Preference cookie

3. If there is NO User Preference cookie...

     a. If the user is NOT in the EU, create it and set the User Preference cookie to "true", meaning trackable

     b. If the user is in the EU, trigger your behavior to get the visitor's tracking consent (or at least inform them), then set the cookie accordingly

4. If there is a User Preference cookie (or you just set it)...

     a. Act accordingly, either loading Munchkin.init() or not.. and if not, you likely want to expunge the cookie as well!


Easy, right?

Since I always go through web forms and web integration options with clients during enablement, I wanted to document this here as a reference guide.


You have a few options when it comes to web forms and Marketo. I’m going to cover the 4 primary methods that my clients choose.


Here’s a quick summary of the primary use case and pros / cons for each:


Header 1

Primary Use Case




Marketo form on Marketo landing page

Gated content, promotional contentEasy for marketers to deploy, i.e. clone and apply tokens!

May prefer to have visitors on your website, instead of Marketo landing pages


Marketo form on website within iframe

Forms you want to keep on your website like contact us, demo forms

Keep visitors on your website while retaining most Marketo form functionality, like form pre-fill

May be more difficult to implement responsive design


Marketo form on website with embed code

Same as Option 2Keep visitors on your web and may be easier to implement than iframe, responsiveRetains less Marketo form functionality than using iframe, e.g. form pre-fill


Use your own form on your website and post data to Marketo using our API

You need to keep your forms bc of other back-end and business requirements
Meets requirements of your existing non-Marketo forms, yet still gets data to MarketoRequires custom development and you don't get Marketo form benefits


OPTION 1. Use a Marketo form on Marketo landing pages.


Use Case: Gated content, promotional content


Pros: Easy to clone, can apply tokens! Great for marketers because it’s easier to execute then going back into your web CMS or bugging your web developer.


Cons: Sometimes you want to keep people on your website, instead of sending them to a separate landing page. For example, you might not want to have your contact us form on a Marketo landing page.


How to Do it:

  • Create a form. Likely you’ll want to create a global form in Design Studio that you can use many times for one use case, e.g. a content download form, a webinar form, an event form.
  • Create a registration page for your form and a thank you landing page, likely within a marketing program that contains all your related campaigns and local assets.
  • Put your global form on the local registration landing page, and edit the form settings within the page to define the thank you page. You can do this at the form level, but you’ll want to do this at the local landing page level if each program has a unique thank you page.


OPTION 2. Use a Marketo form on your website, using an iFrame.


Use Case: Forms that you’d want to keep on your website like contact forms, demo forms.


Pros: Retains most Marketo form functionality like form pre-fill (see the chart on this page which compares features of each form option.)


Cons: May require web help to get the form to look nice.


How to Do it:

  • Create a form. It could be a global for in Design Studio or a local form within a marketing program, like a Contact Form program using a Web Form channel.
  • Put the form on a Marketo landing page using a blank landing page template, then edit the form settings within the landing page to define the thank you page.

  • Grab the URL of the blanking landing page with the form on it and put it on your website using iframe code like this: <iframe src=""></iframe>.
  • You can go back and edit the form CSS as well.
  • In your program, be sure to include a campaign to capture acquisition program because Marketo can’t do this automatically on non-Marketo pages.


OPTION 3. Use a Marketo form on your website, using embed code.


Use Case: Same as above


Pros: Easier to implement, responsive.


Cons: Retains less Marketo form functionality than using an iframe (see the chart on this page which compares features of each form option).


How to Do it:


OPTION 4. Use a non-Marketo form on your website, but post that data to Marketo using our API.


Use Case: Sometimes you just can’t use a Marketo form but you want to post that data to Marketo, for example, if you’re collecting data for a software app, membership portal, e-commerce shop, etc.


Pros: Meets requirements of your current forms that are not available with Marketo forms, yet gets your data into Marketo.


Cons: Requires development resources and you don't get the benefits of Marketo forms (see the chart on this page which compares features of each form option).


How to Do it:


Additional Resource:


I often refer clients to the chart on this blog post because it’s a great summary of the feature benefits of each method above, and then some:

Marketo Forms - Which application is right for you?

After building a scoring model in Marketo and letting it run for a few months, you will want to make sure it is working properly so that you know that people are getting points for the right activities. We'd then recommend revisiting this every six months or so. Here are four fairly straightforward, if sometimes time-consuming, things you can do to validate your scoring model.


1. Make Sure All Campaigns Are Running
The first step is to simply scan your campaigns and make sure that they are all processing records.  You can know whether the campaign is processing data if there are members of the campaign in the campaign overview. 


2. Evaluate Your Scoring Footprint

The scoring footprint looks at the impact that your scoring model has on your database.  In order to understand your scoring footprint, follow these steps:

    1. Create a smart list: lead score is greater than 0
    2. Look at the number of records that has been pulled (e.g. 52,041)
    3. Next, go to the lead database and use the pie chart to get the number of known records in the database (e.g. 103,766)
    4. Use a calculator ( to calculate what percent of your database has a positive score (e.g. 50.2%)


These numbers should be taken every 6 months and kept in Excel.  Over time, you should see a trending increase in the percentage.  If you have a trending decrease, look into what the cause of the decrease is.

Repeat these steps for the behavior score and demographic score as well.


3. Evaluate High Value Attributes and Activities

Use the following steps to look into which attributes or activities are most closely associated with buying behavior:

    1. Create a smart list in the Lead Database called “Became an MQL,” use the filter Revenue Stage was Changed to MQL
    2. Create a Leads by Campaign report (assuming you still have these in your reports, they're a bit of a legacy report) locally within the scoring program, the report should have the following attributes:
    3. Under campaigns, select the scoring model program
    4. Lead created at: All Time
    5. Custom Columns: Became an MQL

For each scoring campaign, this report shows the number of members in the campaign and how many of those members became an MQL.Use Excel to calculate the percentages.  Next, evaluate which activities / attributes are most notable.


In this example, notice that Searched for a Keyword has the highest rate of bringing in qualified leads, so we would want to make sure that this campaign has a high number of points and may want to look into investing in SEO to increase keyword searches.  Adjust your model to reflect your findings.


4. Check Your Values

For demographic scoring, we can use Marketo to understand which values have the highest indication of buying behavior. For each demographic campaign, do the following:

Create a smart list, in this example we will use job title.  The smart list should use the attributes Job Title is not empty and Has Opportunity is true.

Export the list into Excel

Copy all of the job titles from the list in Excel

Paste them into some tool like Wordle (, which is a third party tool that creates a visual diagram for which values appear most frequently in a list.


It's important to not that statistically, you also need to compare how frequently those values appear in your database as a whole. For example, if 50% of your opportunities are created by Managers, but that's also 50% of your overall database, this doesn't tell us much. If however, your database has 20% managers, then there's something more interesting there.

Many thanks to Jep Castelein who pulled much of this information together and tested it.


The best practice within Marketo is to work toward having no duplicate leads , but there are times this happens, especially since Marketo treats SalesForce and Microsoft Dynamics as the source of truth. Duplicates in those systems will result in duplicates in Marketo, and to be clear, a duplicate in Marketo is defined as a lead with the same email address.


I'll use the following as an example


Marketo IDFirst NameEmail


When considering the implications and the behavior of the system with regard to duplicates there are few key areas ..


Batch Campaigns

A batch campaign for which both leads above qualify will only go out to one lead. In this case, it will go out to the one with the LOWER Marketo ID, that is, the one that was created first in Marketo. When the email is sent and clicked on, the activities will be attributed to that lead as well.. and if the link in question leads to a page with munchkin code on it, any activity will also be attributed to this lead.


Trigger Campaigns

These are generally not a problem because they are a "Batch of 1" although they do not de-duplicate in the same way batch campaigns do.


Form Fills

If a lead that exists in Marketo more than once fills out a form, if a cookie exists on the machine they're using, the form filled will be attributed to whatever lead is associated with the cookie.. if NOT, it will be attributed to the lead that was updated most recently in marketo, and of course then the lead would be cookied.


Web tracking

The cookie ID stored within a browser can be linked to only one lead, but of course every browser can have its own cookie, and those can point to different duplicates. This happens when

  • A lead clicks a link in an email
  • A lead submits a form


List Uploads

Uploads will update the most recently updated duplicate


Lead Scoring

This is a big one. Lead scoring is triggered off of things like form fills, web visits, etc, so it follows the rules above. Obviously your risk here is that you can have a split lead score, with different actions attributed to different leads, leading to artificially low lead scores. Its not a huge problem though since much of the lead activity ends up being associated with the most recently updated lead.


Interesting Moments, Activity Types

Activities can end up also spread over multiple duplicates, as with lead scoring.



Another effect of the activity being spread out so you may see lower click and open rates than you might expect. As with the above, its most likely that it's the most recently updated duplicate that is being reported on


So... if your business case requires you to maintain duplicates, just keep this behavior in mind

A colleague of mine put together a nice summary of how cloning and sharing works across workspaces, which I thought might be a useful guide to share.


What Assets Can I Share Across Workspaces?

You can share these items across workspaces:

  • Email Templates (found in Design Studio)
  • Landing Page Templates (found in Design Studio)
  • Models (found in Lead Database)
  • Smart Campaigns (found in Marketing Activities...but we really recommend not having standalone smart campaigns)
  • Smart Lists (found in Lead Database)
  • Segmentations (found in Lead Database)
  • Snippets (found in Design Studio)


How Do I Share Assets?

  • Determine what you want to be shared (e.g. Landing Page Templates)
  • Right click and select New Folder
  • Name the folder you plan to share
  • Move the assets you want to share to the folder
  • Right-click the folder and select Share Folder
  • Select the workspace(s) you want to share the folder with. Click Save.
    • The dialog displays the workspaces you have permissions to view.
    • The originating folder displays in the Lead Database tree with an arrow indicating that it is shared with other workspaces. From within the shared workspace, the folder displays with a lock to indicate that the contents of the folder have been shared from another workspace and are read-only.


How Do I Clone Assets Across Workspaces?

For assets that aren't templates, its best to clone them as local assets inside of a program. With the proper access level, you can drag and drop these assets into another workspace:

  • Programs (found in Marketing Activities)
  • Emails (found in Marketing Activities & Design Studio)
  • Landing Pages (found in Marketing Activities & Design Studio)
  • Forms (found in Marketing Activities & Design Studio)


How Do I Move Assets to a New Workspace?

To move assets to a new workspace, put them into a folder and drag the folder over to the other workspace.

  • Create a folder
  • Clone the asset to the newly created folder NOTE: Form names must be unique.  Append the asset name with the workspace name e.g. Content Form (UK)
  • Drag the folder to the appropriate workspace
  • Move asset to the correct folder within the target workspace

If you’re a new client to Marketo, one of the first things you’ll want to take care of is getting email and landing page templates ready. The sooner you can get this done, the sooner you can start campaigns.

You’ve got 4 options for email and landing page templates in Marketo:

  1. QUICK START: Request Marketo’s free starter templates.
  2. IN THE MIDDLE: Download a template from Marketo’s template library (emails and landing pages) and customize it.
  3. TOTALLY CUSTOM: Upload your own custom template.

Let’s go through the how to’s for each option.


OPTION 1 (QUICK START): Request Marketo’s free starter templates.

When you get a new instance, you can request a few basic starter templates: 5 email templates and 1 landing page template.


Some of these will already be in your Design Studio but if you submit a request at the URL below, our creative services team will replace the generic logo and color with yours.






The email templates look something like this - imagine it with your logo and color:

Screen Shot 2015-11-22 at 9.06.33 PM    Screen Shot 2015-11-22 at 9.06.21 PM

Screen Shot 2015-11-22 at 9.06.11 PM          Screen Shot 2015-11-22 at 9.06.01 PM

Landing Pages:


The landing page template looks something like this - imagine it with your logo, color and header/footer:

Screen Shot 2015-11-22 at 9.06.41 PM

If you plan to rely on our starter templates, note that while the email templates are responsive, the landing page template is not. The starter landing page template is in our free-form mode. See: Understanding Free-form vs Guided Landing Pages).Here are two ways to address this:


Even if you plan to customize your own templates with Options 2-3 below, I recommend requesting these anyway, since 1) these are included and 2) you might need them before your custom templates are done, for example, quick announcement or internal alert emails, and for your unsubscribe page.


OPTION 2 (IN THE MIDDLE): Download a template from Marketo’s template library and customize it.


The second option is somewhere between using our starter templates and designing your own custom templates in terms of how much time and coding skills needed.


Landing Pages:


URL: Marketo’s Landing Page Template Library


Marketo’s landing page template library has dozens of responsive templates that you can download and customize to match your brand. The short instructions on how to import these templates into your Design Studio are at the top of the template library page.



  • When you import into the Design Studio make sure you choose Guided Mode.
  • You should also learn what Guided Mode is and what are and how to edit the two types of editable sections: elements and variables in the guided landing page editor.
  • Once you import the template, you will have to go directly into the code and make your edits, e.g. change color palette, fonts, and add your logo.

Screen Shot 2015-11-22 at 9.33.27 PM




URL: Marketo’s Email Template Library


Go to the link above to download a responsive email template. If you click on the purple import button above a template it will automatically import into your Design Studio (and into a Program Library Imports folder in Marketing Activities).

Screen Shot 2015-11-22 at 9.46.18 PM

Once in your Design Studio, you will have to go directly into the code and make your edits. Go to Emails > Templates and select the template. Click on Edit Template, then on the next page, HMTL Source:

Screen Shot 2015-11-22 at 9.48.00 PM

Screen Shot 2015-11-22 at 9.49.36 PM

OPTION 3 (TOTALLY CUSTOM): Upload your own custom template.


The last option is only for those who can design custom templates from scratch. Perhaps it’s you, or you have an in-house designer or work with an outside agency.


URLS: See below.

Screen Shot 2015-11-22 at 9.36.04 PM

If yes, review or pass along these resources:

  1. A 14-min YouTube Video that reviews how to Create a Guided Landing Page Template.
  2. Marketo documentation on how to Create a Guided Landing Page Template, with required Marketo-specific code to define your own editable elements and variables.
  3. Marketo documentation on how to Add Editable Sections to an Email Template. Essentially, use this div tag to do so: <div class=”mktEditable” id=”UNIQUE_ID”>This part is editable</div>.

Once you’ve created your custom HTML templates, you can import them into the Design Studio. Go to Design Studio > New. From the drop-down, you can select New Landing Page Template or Email Template.

Screen Shot 2015-11-22 at 9.57.25 PM

For emails, simply copy/paste your code into the HTML source:

Screen Shot 2015-11-22 at 10.00.44 PM

For landing pages, make sure to choose Guided Mode when you first create the template. The next page will take you directly to the HTML source where you can copy/paste your custom code.

Screen Shot 2015-11-22 at 10.02.58 PM

OPTION 4: Engage Marketo Creative Services.


Lastly, engage Marketo's creative services team to build your templates to spec. Contact to learn more.

And there you have it – your 4 options for Marketo email and landing page templates!