For nearly a decade, Google Ads scripts have been the unsung heroes for advertisers aiming to automate their accounts.
This means advertisers can directly integrate with the myriad capabilities in the Ads API. They are no longer limited to working with ads entities and functions that the scripts team has enabled.
Google Ads scripts bridge the gap to the Ads API
The recent addition of the mutate function bridges the capability gap between Google Ads scripts and the Google Ads API.
With this integration, advertisers can now directly manipulate and control virtually any component of their Google Ads account, achieving a level of sophistication previously reserved for those interfacing directly with the API.
This evolution embodies how Google seeks to democratize powerful advertising tools, making them accessible to a broader spectrum of users.
The landscape of PPC automation options
The new mutate capability in scripts changes how we should think of automation options in search marketing.
Google Ads scripts are just one of several automation options for PPC advertisers who can also choose to use a third-party PPC management tool, the Ads API, or simpler built-in mechanisms for automation like those in the Google Ads frontend.
Let’s take a look at the advantages and potential drawbacks of each.
Third-party PPC management tools
These are typically comprehensive platforms that provide end-to-end campaign management and features such as:
- Bulk editing.
- Performance reporting.
- Sophisticated automation capabilities.
These tools handle API calls and manage the complexities of maintaining code, making them user-friendly even for non-technical marketers.
However, these tools can have a learning curve and potentially higher costs than in-house solutions.
Google Ads API
The Google Ads API provides robust, granular control over campaigns, allowing for custom automation and integration with other systems. It offers access to all of Google Ads functionalities, including the mutate function.
However, it’s the most technical option, requiring understanding API calls, authentication, and maintaining a server environment.
It’s typically best suited for larger teams with dedicated developers or businesses with highly specific needs that off-the-shelf tools can’t meet.
Google Ads Scripts
Scripts allow for custom automation without the heavy technical lifting of the API.
The recent addition of mutate function support has substantially boosted their capabilities. However, they have execution time limits and aren’t suited for large-scale, complex operations.
Built-in automation in Google Ads frontend
The most straightforward method, this includes features like automated bidding strategies and rules.
These tools are excellent for simple automation tasks and are easily accessible to all advertisers, regardless of technical ability.
However, they lack the customization and control provided by the other methods.
Get the daily newsletter search marketers rely on.
Google Ads scripts use cases
Below are some of the typical things advertisers have automated with scripts:
- Scripts can automate bidding based on a set of predefined rules. This saves time and ensures bids are always optimized for the best performance.
- Custom scripts can be created to generate reports that matter to the advertiser. These could range from keyword performance reports to cost analysis and more. (e.g. Reporting + GPT script)
- Scripts can help automatically adjust campaign budgets based on performance or external factors like seasonality.
Keyword and ad management
- Scripts can add, pause, or remove keywords or ads based on certain conditions, like performance metrics. (e.g., Script to create RSAs with GPT)
Alerts and notifications
- Advertisers can create scripts to alert them about significant changes or potential issues in their account.
These applications of scripts enable advertisers to streamline their operations, focusing on strategic tasks while the scripts take care of these routine activities.
Why the addition of the ‘mutate’ capability in scripts is a game changer
Historically, the Google Ads API has been a stronghold of tool developers, large in-house ad teams, and those with a more profound technical prowess.
Interfacing with the API required a myriad of technical intricacies, including authentication, managing developer tokens, and other nuances not directly tied to ad management.
However, with the recent updates to scripts, the Ads API is no longer the exclusive domain of seasoned developers.
The new capabilities of Google Ads Scripts pave the way for advertisers to transcend the limitations of what was directly supported by the scripts, giving them unprecedented access to the API’s capabilities.
Because scripts handle the technicalities of authentication, tokens, and server management, marketers can focus on what they do best: optimizing ad campaigns and creating value for their brands.
And now, the types of optimizations they can do with scripts are much more extensive.
What does the ‘mutate’ function do?
The mutate capability is a big improvement for scripts users because of its breadth and depth of capabilities.
This feature facilitates most resource modifications, be it creating, updating, or removing things from an ads account.
Here’s a closer look at each one:
The “create” operation is all about giving life to new entities within Google Ads.
Users provide a full JSON representation of the resource they intend to create.
Upon a successful API call, the system response includes the name of the freshly minted object, which can then be further worked with.
Updating existing resources
The API’s “update” operation brings an intuitive approach to making modifications.
Users can perform sparse updates instead of reiterating every detail about a resource.
This means pinpointing only the fields they want to be changed.
The use of the
updateMask attribute allows for this selectivity, ensuring that only specified fields are altered, which becomes especially handy when dealing with objects like campaigns with many settings.
For instance, changing the name and status of a campaign can be done easily without having to know or affecting its other attributes.
Sometimes, decluttering and simplifying are just as vital as creating and updating.
The “remove” operation in the mutate function is geared for this purpose. It doesn’t permanently delete an object but changes its Google Ads status to “
Another benefit of the “mutate” function is its ability to bundle these operations.
Advertisers can send a single API call encompassing multiple actions across different resources, optimizing efficiency.
Moreover, the Google Ads API ensures atomicity – meaning that within a single API request, actions are seen as a set, either entirely succeeding or entirely failing, guaranteeing the consistency of operations.
A few use cases of the ‘mutate’ capability
Making bulk changes across your Google Ads campaigns
One of the standout use cases for the mutate capability in the Google Ads API is to implement bulk changes across campaigns in a single action.
Imagine wanting to adjust bidding strategies for multiple campaigns during high-traffic periods like Black Friday or Christmas.
With the mutate function, advertisers can make sweeping changes across hundreds of campaigns, ad groups, or even keywords, ensuring they maximize their ROI during these crucial periods.
Before this, using only Ads Scripts required crafting more complex, iterative codes and potentially running into execution time limits.
Comprehensive campaign setup processes
Another transformative use case is the holistic creation of campaigns.
Before the mutate capability, setting up a new campaign involved multiple distinct steps: creating the campaign, adding ad groups, assigning keywords, and more. Each of these steps would be its own script function.
Now, with the mutate function, advertisers can design a comprehensive campaign setup where they create the campaign, its associated ad groups, the relevant ads, and the targeted keywords all in a single API call.
This speeds up the process and ensures no element is left out or mistakenly overlooked.
In this example from the Google Developers site, a single call creates a shared budget, a new campaign and a new ad group and places the campaign in the shared budget.
The mutate function offers an integrated error-checking mechanism.
When one element (like an ad group) encounters an error when creating interlinked components, the entire operation can be halted.
This ensures that advertisers don’t end up with half-completed campaigns or structures.
Without the mutate function, scripts would execute sequentially without such an integrated fail-safe, possibly leading to incomplete campaign structures that would require manual checks and corrections.
These are just a few instances that underscore the transformative potential of the mutate function, streamlining processes and ensuring more robust ad campaign management.
A few caveats to consider
While adding “mutate” capabilities to Google Ads scripts opens up new avenues of automated account management, they’re not without limitations.
For example, ad scripts come with a runtime cap of 30 minutes.
Direct API integrations or third-party tools could remain better solutions for intricate tasks that might exceed this time frame.
Revolutionizing Google Ads management
With their newfound capabilities, Google Ads scripts are ushering in a new era of advertising automation.
By bridging the gap between the average advertiser and the once-arcane Google Ads API, they’re making sophisticated ad management more accessible and democratized.
It’s an exciting time for advertisers. Whether you’re a novice venturing into the realm of Google Ads or a seasoned professional, these advancements promise to redefine what’s possible.
Stay informed, experiment, and harness these tools to their full potential!
Opinions expressed in this article are those of the guest author and not necessarily Search Engine Land. Staff authors are listed here.