Automate Marketo Lead Audiences in Google Ads with AI
Turn Marketo lead signals into reviewed Google Ads audiences with an AI-assisted workflow that keeps decisions, customer data, and campaign changes governed.

TL;DR: what you'll build. Marketo lead scores move every hour, but Google Ads audiences often sync weekly, by hand, or never. The demand-generation or paid-media operations lead owns that gap. Close it with a Major app, a Google Ads AI agent for borderline cases, a human approval gate and a deterministic workflow that writes the approved cohort into Google Ads Customer Match.
Why this workflow exists
A demand-generation or paid-media operations lead knows which accounts Adobe Marketo Engage is scoring as high-intent. Getting that cohort into a Google Ads Customer Match list usually waits on someone exporting a CSV.
The workflow reads Marketo lead score and activity data on a schedule, the agent classifies the ambiguous cases, and after a person approves the eligible cohort, the workflow syncs it into Google Ads.
This sits one level below the broader pattern covered in AI agents for marketing. It also overlaps with the qualification work described in AI agents for lead generation.
The marketing problem: Marketo intent rarely reaches paid audiences fast enough
Marketo tracks lead score, program membership and smart-campaign activity down to the hour. Google Ads targeting decisions usually run on whatever audience list was last uploaded, sometimes weeks earlier.
The demand-generation director or paid-media operations lead feels this lag. Budget keeps flowing to broad search terms while the accounts Marketo has flagged as actively engaging sit untargeted, because nobody owns the manual export-and-upload step closely enough to do it daily.
What the fix is, and what it is not
The fix is not "let AI run the ad account." It is a bounded, inspectable sync made of four parts:
- A scheduled read of Marketo lead and activity data.
- A judgment step for borderline cases.
- A human approval gate.
- A deterministic write into Google Ads Customer Match.
Nothing about this promises better return on ad spend or lower cost per click. It closes a specific operational gap between two systems that currently don't talk to each other on a useful cadence.
Systems and data in a Marketo-to-Google Ads workflow
Adobe Marketo Engage: where the signal lives
Marketo's REST API reference splits into two families:
- Lead Database APIs cover Leads and associated objects like Opportunities and Companies.
- Asset APIs cover programs and marketing collateral.
For this workflow, four objects matter:
- Leads hold the score, custom fields and consent status.
- Activities hold smart-campaign triggers, email opens and form fills.
- Smart Campaigns hold the nurture logic that produced the score change.
- Programs give campaign membership context.
Marketo authentication and limits
Authentication is 2-legged OAuth 2.0 client credentials. A custom service tied to an API-only user produces a client ID and client secret, which you exchange for a bearer token that expires in 3,600 seconds.
Marketo's documented limits:
- A daily quota of 50,000 API calls per subscription.
- A rate limit of 100 calls per 20 seconds per instance.
- A concurrency limit of 10 simultaneous calls.
- An 8 KB URI length and 1 MB body size for standard calls.
- Up to 10 MB for bulk calls.
The Marketo gotcha: errors that look like success
A call that errors still frequently returns HTTP 200. The failure is buried in a success: false field and an errors array in the JSON body, so a sync job that only checks the status code will miss failures silently.
Google Ads: where the cohort lands
The Google Ads API exposes Campaigns, Ad Groups, Ads, Keywords, Conversions and Budgets. You query them through GAQL (Google Ads Query Language) over gRPC or REST. The API is built for managing accounts and campaigns programmatically, not for ad-hoc reporting pulls.
Audience work for this use case runs through Customer Match. The documented flow has four steps:
- Create an empty customer list.
- Build an offline user data job against it.
- Populate the job's
consentfield on every create operation. - Add identifiers through
OfflineUserDataJobService.AddOfflineUserDataJobOperations.
Google recommends batching up to 10,000 identifiers per call. A single request is capped at 100,000 identifiers across all UserData objects.
Two Google Ads conditions to check before you build
First, Customer Match eligibility depends on account history: a good record of policy compliance and payment.
Second, under the current Google Ads API deprecation schedule, calls to OfflineUserDataJobService and UserDataService fail with CUSTOMER_NOT_ALLOWLISTED_FOR_THIS_FEATURE unless the developer's Google Cloud project already has Customer Match activity on record. Google now points new integrations toward the Data Manager API for Customer Match uploads.
Authentication runs on OAuth 2.0 plus a developer token tied to a manager account. Operations-per-day quotas scale with the token's access level.
Consent and privacy obligations
This workflow moves first-party personal data, such as email addresses and phone numbers, between two systems for ad targeting. That touches the marketing function's standing consent obligations:
- GDPR Articles 6 and 7 require a lawful basis and a logged consent record for each contact before that contact's data is processed for targeting.
- The CAN-SPAM framework imposes its own notice and opt-out obligations.
- State privacy law (CCPA/CPRA) imposes notice and opt-out obligations as well.
A Customer Match create operation without a correctly populated consent field will be rejected by Google's API with OfflineUserDataJobError.CUSTOMER_NOT_ACCEPTED_CUSTOMER_DATA_TERMS.

Marketo lead audience sync architecture: app, agent, and workflow responsibilities
Split the workflow across app, agent, and deterministic steps
Conflating these three layers is where most "AI runs my ad account" pitches go wrong.
The app: control surface and system of record
The app holds everything that needs to persist about this process:
- The cohort criteria, such as score thresholds and activity recency windows.
- The queue of leads currently under review.
- The consent and eligibility status per lead.
- The approval history.
- Every sync receipt Google Ads returns.
None of that state should live inside a prompt or a chat transcript. It needs to persist between runs, be queryable by the paid-media owner and survive a restart.
The agent: judgment on ambiguous cases only
The agent does one kind of work: judgment on borderline records. A lead that crossed the score threshold three days ago and has had no activity since is neither a clean match nor a clean non-match. A lead with a borderline score but a recent demo-request form fill might deserve inclusion anyway.
The agent explains its recommendation in plain language and writes a recommended cohort label back to the app. It does not decide to upload records on its own, and it never touches the Google Ads account directly.
The workflow: the deterministic, repeatable part
The workflow handles every step that should behave the same way each time:
- The scheduled read from Marketo.
- The normalization step.
- The threshold check against score and recency.
- The human approval gate.
- The write to Google Ads Customer Match, only after approval.
This is code, not a model call, so it produces a traceable receipt every time it fires. It's the same split described in Google Sheets automation, where the repeatable connector work stays out of the model and only the judgment calls go to an agent.
If the team runs HubSpot alongside Marketo for a different product line, the same pattern applies with different objects. See AI agents for HubSpot for that variant, since HubSpot's contact and list model differs from Marketo's Lead Database structure.
Build the Marketo audience sync on Major as a Google Ads AI agent workflow
- Connect Marketo and Google Ads as custom API connectors, since neither tool has a pre-built Major connector today: configure Marketo with the instance's REST endpoint and an OAuth 2.0 client-credentials grant (client ID and secret from a LaunchPoint custom service, scoped to a read-only API user), and configure Google Ads with OAuth 2.0 plus the manager account's developer token, storing both in Major's credential proxy scoped to this workflow and never in agent prompts or app code. You should see both connectors listed in Major, with credentials held by the credential proxy.
- Model the data with three tables: marketoleads (lead ID, score, last activity timestamp, consent status, source program), cohortqueue (lead ID, proposed cohort label, agent rationale, review status, reviewer, decision timestamp) and sync_receipts (batch ID, Google Ads job ID, record count, status, error detail, reconciled-at timestamp). You should see three empty tables with these columns, ready for the first scheduled read.
- Build the app with its own prompt (shown first below), so it lists qualifying leads, groups them into a review queue and lets a signed-in user approve, reject or hold each batch with a logged reason. You should see a review queue where each batch has approve, reject and hold controls and a reason field.
- Add the agent with a separate prompt (shown second below), limited to leads whose score and recency fall near the configured thresholds and forbidden from recommending any record whose consent is missing or denied. You should see borderline leads in the queue carrying an include, exclude or hold recommendation with a one-sentence rationale.
- Set the scheduled workflow trigger to read Marketo on a configurable interval rather than a fixed cadence, matching how often the account's lead scores actually move and how much review capacity the paid-media owner has. You should see the workflow fire on the interval you chose and populate the marketo_leads table on each run.
- Gate the workflow on human approval so it pauses after the agent's recommendation and before any Google Ads call, letting the paid-media operations owner approve or reject per record or per batch in the app, with only approved records moving forward. You should see the workflow waiting in a paused state until a reviewer acts, with no Google Ads calls made in the meantime.
- Sync and reconcile on approval: the workflow builds the offline user data job, populates consent, adds operations in batches under Google's documented limits, writes the job ID and status to syncreceipts, and on the next scheduled run checks for any records that didn't confirm successfully. You should see a new row in syncreceipts for each batch, with its Google Ads job ID, record count and status.
- Test the failure paths before trusting the sync, checking that a Marketo response with HTTP 200 but a failed body is caught, that rate-limit and quota hits back off to the next window, and that a record with missing consent is excluded or sent down the remove-only path. You should see each failure recorded with error detail in sync_receipts or the queue instead of passing silently.
- Roll out with permissions by restricting batch approval to the paid-media operations team through SSO and role-based access, keeping Marketo on a read-only API role and Google Ads on a manager-account-scoped OAuth client, and versioning every deploy of the app and workflow. You should see only paid-media operations users able to approve batches, and every threshold or recency change appear as a tracked deploy.
Prompt for the app:
Build an app that lists leads from the marketo_leads table with score above a configurable threshold and activity within a configurable recency window, groups them into a review queue, and lets a signed-in user approve, reject, or hold each batch with a logged reason.
Prompt for the agent:
When a lead's score and recency fall near the configured thresholds, review its recent Activities records and recommend include, exclude, or hold with a one-sentence rationale. Never recommend uploading a record whose consent field is missing or denied.
<p><a href="https://app.major.build/?utmsource=blog&utmmedium=blogcta&utmcampaign=seousecase&utm_content=google-ads-ai-agent">Start building this sync on Major</a> once the connectors and credentials are in place.</p>

Cohort approval path: reject, retry, and sync receipt branches
Governance, edge cases, and what to measure
Governance
Only the paid-media operations team can approve a batch, enforced through SSO and role-based access. Every approval, rejection and hold is logged with a timestamp and reviewer identity.
Marketo and Google Ads credentials sit behind Major's credential proxy, scoped to the minimum permissions each call needs:
- Marketo lead pull → a read-only Marketo API role.
- Google Ads upload → a manager-account-scoped Google Ads OAuth client.
These credentials are never hard-coded or visible to the agent's reasoning.
Consent and eligibility
The workflow checks consent.ad_user_data and consent.ad_personalization before including a record in any create operation. A record missing consent gets a remove-only path or is excluded from the batch entirely, per Google's documented behavior for unconsented EEA users.
The advertiser must confirm Customer Match eligibility independently; a workflow cannot verify or override it.
Failure handling on the Marketo side
Check every Marketo response body for the failed success flag, not just the HTTP 200 status.
Hitting any of these limits should back off and retry on the next window rather than fail the whole batch:
- The daily call quota.
- The 100-calls-per-20-seconds rate limit.
- The 10-concurrent-call ceiling.
Failure handling on the Google Ads side
An allowlist error from Google Ads means the developer's Google Cloud project needs Customer Match re-enabled, or needs to move to the Data Manager API path Google now documents for this feature.
A partial upload, where some identifiers in a batch are accepted and others rejected, should be reconciled against the job's reported status before the next sync runs, not silently retried into a duplicate.
Limits on what the agent can do
The agent should never, on its own judgment:
- Retry a failed upload.
- Change the score threshold.
- Expand the cohort beyond what a human approved.
Any of those require a person back in the loop.
Stale and duplicate data
A lead whose score changed twice between sync cycles should reflect its most recent state, not an average or a stacked history. The marketo_leads table should overwrite, not append, keyed on lead ID, so running the same sync twice leaves the same state.
Records already present in the live Google Ads customer list from a prior cycle should be excluded from the next job's create operations. That avoids redundant calls against the API's rate limits.
What to measure
Track these process health metrics:
- The lag between a Marketo score crossing threshold and that lead appearing in the Google Ads audience.
- The number of records the agent flagged for human review versus auto-qualified.
- The approval-to-rejection ratio per cycle, a signal the thresholds need tuning.
- The count of sync failures or partial uploads per run.
- The age of the oldest unreconciled sync receipt.
The demand-generation team can act on these directly; they are not claims about ad performance.
Before you go live
- [ ] Confirm Customer Match eligibility (policy compliance and payment history) and that the Google Cloud project has Customer Match activity on record, or plan for the Data Manager API path.
- [ ] Verify Marketo uses a read-only API user and Google Ads uses a manager-account-scoped OAuth client and developer token, both held in Major's credential proxy.
- [ ] Check that the sync inspects the Marketo response body for a failed success flag and errors array, not just the HTTP status.
- [ ] Confirm backoff for the 50,000 daily calls, 100 calls per 20 seconds and 10 concurrent calls limits.
- [ ] Test that records missing ad user data or ad personalization consent are excluded or sent down the remove-only path.
- [ ] Verify upload batches stay at or under 10,000 identifiers per call and 100,000 per request.
- [ ] Restrict batch approval to the paid-media operations team through SSO and role-based access, with every decision logging a reviewer and timestamp.
- [ ] Confirm the marketoleads table overwrites on lead ID and partial uploads reconcile against syncreceipts before the next run.
Start building on Major
Set up the Marketo and Google Ads connectors, model the lead and cohort tables, and let an agent handle only the borderline scoring calls while a workflow handles the rest, with a human approval gate before anything reaches a live Google Ads audience.
Related articles
- Automate ZoomInfo-to-Outreach Lead Handoffs on Major
- Salesforce Zendesk Integration for Renewal-Risk Alerts
- NetSuite Integration: Automate the Manufacturing Handoff
About the author
Ritvij Gautam is Head of Growth at Major.
Last reviewed November 6, 2026 by Ritvij Gautam.
Frequently asked questions
- What can an AI agent do in Google Ads?
- An AI agent can recommend audience segments, flag anomalies, and draft reporting summaries, but it should not autonomously change bids or budgets. A bounded example is an agent that classifies ambiguous Marketo lead-score and activity data into cohorts, which a human then approves before a deterministic workflow syncs it into a Google Ads Customer Match audience.
- Can Marketo lead scores be used to build Google Ads audiences?
- Yes, through a staged first-party match: Marketo lead score and activity data feed a cohort that gets uploaded to Google Ads as a Customer Match audience. This requires verifying Customer Match account eligibility, logging consent per contact, and following Google's current identifier and upload requirements before any sync runs.
- How often should a Marketo-to-Google Ads audience sync run?
- There is no universal cadence. Match the schedule to how fast lead scores actually change in Marketo, the Google Ads API's operations-per-day quota for the developer token, and how much review capacity the paid-media team has to approve each batch before it uploads.
- Should an AI agent change Google Ads bids automatically?
- No. Bid and budget decisions should stay with a human reviewer. The agent's role is limited to classifying ambiguous lead cohorts; a deterministic workflow handles the repeatable sync, and any change to targeting or spend needs an approval step and a rollback path before it takes effect.