Author: Eric Keller

Teams across industries are finalizing their 2025 budget proposals.

But how can they get their requests approved?

Lauren McCormack (Vice President, Revenue Pulse) and Brooke Bartos (Director of Marketing Operations & Analytics, InvoiceCloud) have the answers.

Last week, they hosted a practical session on creating compelling budget requests so your marketing team can get the resources it needs for the year ahead.

It features 5 actionable tips for justifying your budget, including a Business Case Template you can view and download here.

Watch the FULL recording above!

This is an important time of year.

We’re in a crucial planning season as teams across industries finalize their budget proposals.

And the question that many marketers have on their mind is:

How can I ensure these budget requests are approved by leadership?

Especially when marketing budgets continue to shrink year-over-year.

Which is why we’ve put together 7 practical tips for creating a budget proposal that leadership can rally behind.

Let’s get into it.

1. Identify Business Goals

Start by zooming out. Look at the broader business objectives that your company is trying to achieve. Whether you’re looking to enhance brand visibility, capture new customer segments, or support a major product launch, these high-level objectives serve as your guiding lights or “north stars.”

Every line in your budget should trace back to these fundamental goals, demonstrating to leadership that your proposed spending aligns with organizational priorities.
 

2. Understand Your Industry

With business goals in mind, take a closer look at market trends and competitor activities. Understanding your industry lets you emulate proven successful strategies, as well as identify opportunities your competitors have missed.

For example, should you invest in a heavily saturated channel? Or should you explore new channels that no one in your space has leveraged? Maybe there is a case to be made for both. A well-researched competitive analysis can help justify either approach.
 

3. Understand Your Target Audience

You can have the greatest campaign ever with strong branding and impactful copy. But if it’s not being put in front of the right people, it won’t produce the results you’re hoping for.

So if you haven’t already, start by developing data-driven Ideal Customer Profiles (ICPs) – we actually conducted an experiment on using ChatGPT to define your true ICP.

From there, identify leads in your database that match these profiles. Then, craft messaging that speaks directly to their needs, pain points, and decision-making authority.

And remember that audience targeting is an iterative process. Monitor your response rates, test different messaging approaches, and be ready to adapt based on results. Your budget allocation should reflect this commitment to continuous refinement (ie. Instead of allocating all your digital advertising spend upfront, space it out to reflect different phases of testing and optimization month-to-month.)

Note: It’s not enough to just have well-defined ICPs and good messaging; it’s equally important to keep your database up-to-date and free of duplicates. Dirty data will cause all sorts of other problems such as lost revenue and productivity, data privacy violation risks, and unreliable decision-making. Here’s how to create a data hygiene plan that works.
 

4. Determine the Right Marketing Channels

Knowing your audience is only half the battle. You need to meet them where they are. Is it most effective to reach them through social media platforms, SEO strategies, email marketing, TV and print advertising, or all of them?

Evaluate your options and allocate budget across channels that reflect both audience behavior and channel performance data.

But don’t spread yourself too thin either; It’s better to excel on a few key platforms than to maintain a mediocre presence everywhere.
 

5. Learn From Past Performance

Nothing builds credibility like proven success. Review your previous campaigns thoroughly and see what worked and what didn’t. Doing this allows you to learn from previous mistakes, recreate proven strategies, and build on past wins as you expand your scope.

When you’re presenting your budget to leadership, highlight those specific examples where strong ROI was delivered. These examples act as valuable proof of concept, showing that you can be trusted with resources.
 

6. Project Results (Especially Revenue Growth)

Building on your historical analysis from the previous tip, take things one step further by creating detailed projections for future campaigns. Leadership will have more confidence in your vision when you support it with reliable projections backed by good data.

Projected revenue growth is especially important here. Highlighting how your proposed initiatives will directly contribute to increased revenue is a language your CFO (and the entire leadership team) will understand.

It’s also a good idea to develop a system of transparency and accountability through regular check-ins – maybe in the form of a continuously updating model that leadership can monitor throughout the year, for example. This kind of thing will help maintain trust and is generally good practice.
 

7. Focus on the Opportunity

At the end of the day, leadership can overlook cost if the ROI makes sense. This is why it’s important to focus on the opportunity that your budget creates.

When you’re communicating with leadership, focus on the high-level vision. Paint a picture of the potential benefits while showing how your plan aligns with broader organizational goals.

And keep it simple! Overly technical details might lose them. Instead, emphasize value and outcomes.

Because when they trust your vision, they’re far more likely to invest in your plan.

As we’ve mentioned, marketing budgets are shrinking – which makes compelling budget proposals vital to the success of your team and your company.

In order to get buy-in, you need a convincing narrative backed by solid data. Use these tips to help you create a budget proposal that presents a clear vision for growth that leadership can confidently get behind.

And if you want to dive deeper into this topic, don’t miss our upcoming presentation called “Don’t Ask, Don’t Get: How to Secure Budget for Your Team in 2025”.

Learn more and save your spot here!

This is one of every marketer’s worst nightmares 👻:

Your plate is full and you barely have time to finish your tasks for the day, when your Marketing Manager asks you to upload a list to Marketo ASAP.

You get it done quickly, but your SDR says the leads have the wrong information!

The list is full of bad formatting and incorrect entries.

It’s a disaster. Some leads have already existed in your database for years and now have the wrong job titles, others have come from different sources, etc.

Fortunately, Marketo’s API has a solution – a “time machine” of sorts that allows us to revert data changes.

In this guide, we’ll show you how to roll back your data using the API.

Let’s get into it!

(This guide is for Marketo users and assumes a basic understanding of the Marketo API. If you want to learn more, check out our API webinar and an extensive API course by Tyron Pretorius.)

Note: Whenever we use the Marketo APIs, remember to obtain a Marketo API access token before anything else. This will be required to communicate with the API.

Step 1. Extract data value change activities.

First, we need to identify the recent data changes that occurred when we uploaded the faulty list. 

Using the Marketo API, we can pull a log of data value change activities. This will give us both the old values and the new (incorrect) values, allowing us to update lead fields with the original old values via the API in later steps. 

Start by acquiring the “paging token” using this code snippet:

 url="https://"+MUNCHKIN+".mktorest.com/rest/v1/activities/pagingtoken.json"
token=get_access_token()
params={'access_token': token,
        'sinceDatetime':sinceDate}
response=requests.get(url=url,params=params)
data=response.json()
nextPageToken=data['nextPageToken']

 
Next, use this code snippet to extract data value change activities:

url="https://"+MUNCHKIN+".mktorest.com/rest/v1/activities.json"
params={'access_token': token,
        'nextPageToken': nextPageToken,
        'activityTypeIds':[13],
        'listId': listID}
response=requests.get(url=url,params=params)
data=response.json()
print(data)
act=data['result']
while data['moreResult']==True:
    nextPageToken=data['nextPageToken']
    token=get_access_token()
    params={'access_token': token,
                'nextPageToken': nextPageToken,
                'activityTypeIds':[13],
                'listId': listID}
    response=requests.get(url=url,params=params)
    data=response.json()
    print(data)
    act=act+(data['result'])

Step 2. Isolate the old values from the list import.

Now that we have the activity log, we can pinpoint the old values that were replaced by the faulty list and extract them.

Use this code snippet to do this:

df=pd.json_normalize(act)
df=df[df['primaryAttributeValue']==field]
df=df.sort_values('activityDate')
df=df.reset_index()
df=df.drop(columns=['index'])
df1=pd.json_normalize(df['attributes'])
i=4
while i<len(df1.columns):
    df1=df1.drop(columns=[i])
    i=i+1
df1.columns=['New_Value','Old_Value','Reason','Source','Other']
df1.New_Value=pd.json_normalize(df1.New_Value)['value']
df1.Old_Value=pd.json_normalize(df1.Old_Value)['value']
df1.Reason=pd.json_normalize(df1.Reason)['value']
df1.Source=pd.json_normalize(df1.Source)['value']
df=pd.merge(df,df1,left_index=True, right_index=True)
df=df.drop(columns=['attributes'])
df=df.drop_duplicates(subset='leadId', keep="first")

Step 3. Update Marketo fields with the old (original) values.

We can now restore the old values to our leads using the Marketo API. This process requires a specific API call to update each lead’s information back to its original state.

Use this code snippet to get you started:

ids=df[df.columns.to_list()[2]].to_list()
camposval=df['Old_Value'].to_list()
for i in range(len(camposval)):
    if camposval[i] == None:
        camposval[i] = 'NULL'
STEP=300
a=math.ceil(len(ids)/STEP)
i=0
while i < a: 
    tempids=ids[i*STEP:(i+1)*STEP]
    tempcamposval=camposval[i*STEP:(i+1)*STEP]
    params={'action': 'updateOnly',
            'lookupField': 'id',
            'input':[]}
    j=0
    while j<len(tempids):
        lead={'id':tempids[j],
              fieldRest:tempcamposval[j]}
        params['input'].append(lead)
        j=j+1
    token=get_access_token()
    url="https://"+MUNCHKIN+".mktorest.com/rest/v1/leads.json?access_token="+token
    headers={'content-type': 'application/json'}
    i=i+1
    response=requests.post(url=url,data=json.dumps(params), headers=headers)
    print(response.json()['result'])

 
Now, when we look at our Marketo instance, all the lead values should be reverted back to what they were before the faulty list was uploaded – crisis averted!

With a deep understanding of the Marketo API, we can find efficient solutions like this to problems that would normally require countless hours of manual cleanup.

So, next time you mistakenly upload a bad list, don’t panic!

Use this guide as a framework to quickly and efficiently reverse those changes, ensuring your SDRs have the most accurate lead information possible.

If you need help with this guide or have any other questions about the Marketo API, you can book a chat with us here.

If you’re a Marketo user, you’ll know that it’s great at scaling.

It offers robust templates and tokens to streamline marketing operations.

But with that said, there can still be plenty of manual work involved in the form of cloning programs, updating tokens, and activating smart campaigns.

If you’re running an instance with 10 campaigns per day, for example, that’s going to be a real challenge. And if it has 1000 campaigns per day, it’s pretty much impossible to maintain accuracy and consistency — even if you have an amazing team.

The solution: leverage the Marketo API to automate these repetitive processes.

In this guide, we’ll show you how to harness the Marketo API to save time, ensure consistency, and enable greater scalability across your marketing initiatives.

Let’s get into it!

(This guide is for Marketo users and assumes a basic understanding of the Marketo API. If you want to learn more about the API, check out our webinar as well as an extensive course by Tyron Pretorius.)

Note: It’s important to remember that we must always start by obtaining a Marketo API access token.

1. Cloning Programs

Imagine you need to create 25 webinar programs that each require unique details. This would be pretty time-consuming to manually complete, so we’re going to use the API to automate the entire process.

Let’s start with a Python script that will automatically clone your program:

def clone_program(programName,programId,folderId):
    url="https://"+MUNCHKIN+".mktorest.com/rest/asset/v1/program/"+programId+"/clone.json"
    token=get_access_token()
    params={'access_token': token,
           "Content-Type": "application/x-www-form-urlencoded"}
    body="name="+programName+"&folder={'id':"+folderId+",'type':'Folder'}"
    url=url+"?"+body
    response=requests.post(url=url,params=params)
    data=response.json()
    programid=data['result'][0]['id']
    return programid 

2. Updating Tokens

Now that our programs are cloned, we need to populate them with the correct values. Using the API, we can update text tokens, date tokens, etc. across multiple programs simultaneously — saving time and reducing the risk of outdated information being sent to our audience.

Use this Python script for updating text tokens:

def updateTextToken(programid,tokenName,tokenValue):
    url = "https://"+MUNCHKIN+".mktorest.com/rest/asset/v1/folder/"+str(programid)+"/tokens.json"
    token=get_access_token()
    headers = {
        "Authorization": "Bearer "+token,
        "Content-Type": "application/x-www-form-urlencoded"}
    body="name="+tokenName+"&value="+str(tokenValue)+"&type=text&folderType=Program"
    url=url+"?"+body
    response = requests.post(url, headers=headers)
    data=response.json()

3. Activating Smart Campaigns

Finally, we must bring our programs to life by activating our smart campaigns.

Use this last Python script to achieve this:

def activateSC(campaigns):
    for campaign in campaigns:        url="https://"+MUNCHKIN+".mktorest.com/rest/asset/v1/smartCampaign/"+str(campaign)+"/activate.json"
        token=get_access_token()
        params={'access_token': token}
        response=requests.post(url=url,params=params)
        data=response.json()

With Great Power Comes Great Responsibility

While the Marketo API opens up a world of automation possibilities, we need to use it wisely.

Here are a few major considerations we want to leave you with:

1. Always have a backup plan.

If you’re going to clone 25 programs, for example, make sure you can delete those 25 programs if necessary. Create a “delete campaign” as a safety net so you can undo any changes.

2. Test, test, test.

In your typical development process, you would usually build things in a lower “beta” environment where everything can be tested. In Marketo, you can’t do this. You need to test things in production to see what your results are going to be.

For example, if you want to update 100 landing pages using the API, start by updating just 1 landing page first. Did the changes to that page go through as planned? If the answer is no, you’ll need to go back and fix things before you bulk-update the next 99 pages. Then retest the change, and so on.

Automation is our friend, but we don’t want to create more technical debt — and we definitely don’t want to create technical debt that we can’t automate.

As long as we keep this in mind and proceed with caution, we’ll be fine!

By carefully leveraging the Marketo API to automate these repetitive processes, we’re:

✅ Improving consistency
✅ Enabling greater scalability
✅ Freeing up valuable time for more strategic initiatives

And if you need any help using the Marketo API, book a 30-min call with one of our experts here!

Nearly every Marketo instance will eventually have duplicate leads.

They can come from list uploads, form fills, CRM syncs, manual lead creation, and much more.

And since Marketo subscription costs scale with database size, duplicates are a major problem for your budget.

While manual deduplication is time-consuming and impractical, leaving the issue unaddressed will impact analytics, campaign efficiency, and ultimately, your bottom line.

Fortunately, the Marketo API solves this directly by allowing us to perform cost-effective, mass deduplication of leads.

Here’s a step-by-step guide on how it’s done!

(This guide is for those with a foundational understanding of the Marketo API and is designed for Marketo users. If you want to learn more about the Marketo API, check out our API webinar and an extensive API course.)

1. Extract Duplicates from Marketo Using a List Export

The first step in the deduplication process is to identify and extract the duplicate leads from your Marketo instance.

In Marketo, create a Smart List that identifies duplicate leads based on your chosen criteria (e.g., email address). Once your Smart List is populated, select all the leads and export them to a CSV file. You should have something similar to the screenshot below before you export.

This exported list will serve as your reference for the deduplication process (and provide a backup in case of any issues.)
 

2. Define Your Winner Criteria and Deduplication Rules

Before we start merging leads, it’s crucial to establish clear rules for determining which lead will be the “winner” (the consolidated lead that will remain after merging several duplicates). We must also define rules on how to handle conflicting data.

In our case, we want the oldest lead to be chosen as the winner to preserve the original acquisition date. But at the same time, we want to maintain paid media as the lead source.

Feel free to define your rules and criteria as needed – you may want to maintain the most recent phone number, job title, subscription status, and other characteristics as well.
 

3. Deduplicate Leads Based on the Winner Criteria

By now, we should have an exported list of duplicates and a winner criterion. The next step is to perform mass deduplication through the Marketo API (learn more about accessing the Marketo API here) using the following Python script:

deduplicate:def deduplicate(winner,losers):
    access_token=get_access_token()
    url = f"{BASE_URL}/rest/v1/leads/{winner}/merge.json"
    headers={
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/json"}
    params = {
        "leadIds": losers
    }
    response = requests.post(url, params=params, headers=headers)
    return(response.json())

 
This will examine groups of duplicate leads, determine the winner based on your criteria, and merge the leads using the Marketo API.
 

4. Update the Winner Lead with Data from the Losing Leads

After merging, we need to ensure that any data we want to keep from “losing” leads (such as paid media as a source) is consolidated into the single “winner”.

Here’s a Python script that will update the winner based on our deduplication rules:

def update_lead(leadid,field,value):
	access_token=get_access_token()
	url=f"{BASE_URL}/rest/v1/leads.json"
	headers={
    	"Authorization": f"Bearer {access_token}",
    	"content-type": "application/json"
	}
	params={
    	'action': 'updateOnly',
    	'lookupField': 'id',
    	'input':[{
        	'id': leadid,
        	field: value
    	}]}
	response=requests.post(url=url,data=json.dumps(params), headers=headers)
	print(response.json()['result'])

 
The last thing we need to do is run a Python script that will execute all these functions together (prioritizing the oldest lead as the winner and paid media lead source):

df_aux=df[df['Email Address']==email]
    leads=list(df_aux['Id'])
    winner=min(leads)
    leads.remove(winner)
    deduplicate(winner,str(leads)[1:len(str(leads))-1])
    if (df_aux['Lead Source']=='Paid Media').sum()>0:
        update_lead(winner, 'LeadSource', 'Paid Media')

 
And that’s it! Now, all of our duplicates have successfully been merged with data from our deduplication rules preserved for each one.

By taking advantage of the Marketo API to implement an efficient deduplication process for your Marketo database, you’ll be maintaining good data hygiene, which improves marketing effectiveness and leads to direct cost savings.

And while this guide provides a solid foundation for deduplication, every organization’s needs are unique. You may need to adjust the winner criteria and deduplication rules to best suit your specific requirements.

If you need help implementing this deduplication process or have questions about optimizing your Marketo instance, book a 30-minute chat with us here!

By taking advantage of the Marketo API:

Marketers unlock a gold mine of data that can support overall strategy in a major way.

But this can be intimidating for folks who haven’t used the API before.

This is why we decided to present:

“Marketo APIs: 3 Easy Ways to Activate Your Data”.

Our goal with this event was to make the Marketo APIs more accessible for marketers and demonstrate easy use cases that add a ton of value.

Hosted by: Lucas Machado (Director of AI & Automation, RP), Corey Bayless (Director, Prudential Financial), Lauren McCormack (Vice President, RP).

The FULL recording is available  above.

Here’s a brief overview of what we covered.

After a quick introduction, we started by covering API fundamentals including what APIs are, why you should care, and Markto API basics.

From there, we covered not 3, but 5 Marketo API use cases!

1. Extract Bulk Activity Logs

This is a simple, but very powerful use case. While Marketo allows us to extract individual activity logs, it doesn’t allow us to extract them in bulk. Bulk logs are useful for analyzing email data, uncovering why opportunities were created, and much more. Watch above for a step-by-step walkthrough on how to extract bulk activity logs using the Marketo API.

2. Revert Data Changes

If you’ve ever been in a situation where you uploaded the wrong list to Marketo — or if the data was badly formatted — this will be a lifesaver. In the webinar above, learn how to use the Marketo API to reverse the data changes from a list upload. 

3. Create Programs

Marketo is great at scaling. But there can still be a lot of manual work in the form of cloning programs, updating tokens, activating smart campaigns, and so on. If you’re running an instance with 100 campaigns per day then it will be pretty much impossible to keep track of it all. Fortunately, we cover how the Marketo API can be used to automate many of these manual processes — saving you time and enabling greater consistency and scalability. 

4. Deduplication

Nearly every Marketo instance will eventually harbor duplicate leads. They can come from list uploads, form fills, CRM syncs, manual lead creation, etc. And since Marketo subscription costs scale with database size, duplicates are a major problem. Fixing them manually isn’t realistic either simply because of how long it takes. The Marketo API solves this directly by allowing you to perform mass deduplication in your instance. 

5. Data Pipelines

Our final application uses the Marketo API to import outside data into static lists within your Marketo instance. This is extremely useful because not all SaaS platforms have code-free integration with Marketo. The API offers users a way to get data from those platforms (such as Oracle or Snowflake) into their instance without a ton of time-consuming manual coding work to keep Marketo lists up to date. 

Be sure to check out the webinar recording above for an in-depth demonstration of how to apply these use cases.

And if you have any questions about the Marketo API, don’t hesitate to reach out to us!