Make.com Ad Spy Automation: The Competitor Intelligence Cookbook

Make.com ad spy automation works because of an architectural accident: Make's iterator model and ad intelligence data share the same shape. An ad library API returns one response holding an array of ads. Make's iterator splits arrays into bundles and runs every downstream module once per bundle. Per-ad processing, the exact thing competitor research needs, falls out of the platform for free.

TL;DR: This cookbook gives you five production-ready Make scenarios built on the AdLibrary API: a competitor watchlist sweep, a creative-format dashboard feed, new-advertiser discovery by keyword, a router-driven enrichment pipeline, and a monthly winners report pushed to Google Docs. You get the exact HTTP module config, the iterator and aggregator patterns that keep operations cheap, and the credit math to schedule everything on a Business plan without blowing the budget.

Most agency automation specialists discover this the slow way, one overbuilt scenario at a time, before realizing the whole ad spy discipline maps onto Make unusually well. This cookbook skips that discovery phase.

Why Make's Iterator Model Fits Ad Intelligence Data

Make processes data as bundles. A trigger or HTTP call produces one bundle, and every module after it runs once per bundle it receives. The Iterator converts a single bundle containing an array into N bundles, one per array element. The Aggregator does the reverse, collapsing N bundles back into one.

Ad intelligence data arrives as exactly that structure. A search against the AdLibrary API returns a results array where each element is one ad: advertiser name, copy, creative URL, engagement counts, impressions, runtime, heat score. Almost every research question you'd ask is a per-ad question. Is this ad new? Has it run longer than 21 days? Which competitor launched it?

In a script you'd write a for-loop. In Make you drop an Iterator after the HTTP module and the loop builds itself. Filters become per-ad conditionals. A Data store becomes your seen-before memory keyed on ad_key. An Array Aggregator with a Group By field becomes your pivot table. The visual canvas turns competitive intelligence logic into something a non-developer on your team can audit at a glance.

One warning before the recipes. Iterators multiply operations, Make's billing unit. A search returning 60 ads through four downstream modules costs 240 operations, not four. Every scenario below uses filters early and aggregators aggressively to keep that multiplication in check.

What Make.com Ad Spy Automation Actually Looks Like

The stack has three layers: a data source, the Make scenario, and a destination your team already reads.

The data source deserves the most thought. Meta's Ad Library API is the originator of programmatic ad transparency and it is genuinely free. It is also Meta-only, scoped to political and social-issue ads in most regions, and gated behind app review plus access tokens that expire every 60 days. Fine if Facebook is your only battlefield. The moment a client asks what a competitor runs on TikTok, YouTube, and LinkedIn in the same breath, you need a different source. The full comparison lives in our Meta Ad Library free API breakdown.

These recipes use the AdLibrary API, the paid power-user route. Three properties make it the better fit for Make.com ad spy automation specifically. First, one search spans eleven platforms, including Facebook, Instagram, TikTok, YouTube, Google, and LinkedIn, so one HTTP module replaces a sprawl of per-platform branches. Second, results carry performance signals Meta's free API never exposes for commercial ads: spend estimates, a 0-1000 heat score, impressions, and runtime in days. Your filters can key on real traction instead of recency alone. Third, auth is one adl_ API key sent as a bearer token. No app review, no token refresh scenario babysitting your other scenarios.

Pricing is credit-based. A search costs 1 credit per page, an AI creative teardown costs 1, and a full winners scan costs a flat 10. API access comes with the Business plan at €329/mo with 1000+ monthly credits, and the credit math section below shows that a serious five-scenario stack fits inside that allowance with headroom.

Destinations are Google Sheets, Slack, and Google Docs because most agencies already live there. Swap in Airtable or Notion freely.

The HTTP Module Config You'll Clone Into Every Scenario

Every make.com ad spy automation recipe starts with the same HTTP module. Build it once, save the scenario as a template, and clone it.

Test the call in a terminal first so you debug the API and the scenario separately:

curl "https://adlibrary.com/api/search" \
  -H "Authorization: Bearer adl_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "keyword": "protein powder",
    "appType": "3",
    "platform": ["facebook", "instagram", "tiktok"],
    "geo": ["USA"],
    "sortField": "-impression",
    "daysBack": 30
  }'

Then mirror it in Make's HTTP "Make a request" module:

• URL: https://adlibrary.com/api/search
• Method: POST
• Headers: Authorization: Bearer adl_your_api_key and Content-Type: application/json
• Body type: Raw, content type JSON
• Request content: the JSON body from the curl test
• Parse response: Yes

Parse response is the setting people miss. Without it the response arrives as a text blob and the Iterator has nothing to map. With it, Make exposes the full structure as mappable fields:

{
  "results": [
    {
      "ad_key": "meta_123456789",
      "advertiser_name": "Acme Running",
      "platform": "facebook",
      "title": "The shoe that runs with you",
      "body": "Lightweight. Responsive. Built for race day.",
      "ads_type": 2,
      "impression": 1840000,
      "heat": 812,
      "days_count": 89,
      "first_seen": 1748390400,
      "landing_page_url": "https://acme.example/run"
    }
  ],
  "total": 327,
  "page": 1,
  "_credits": { "used": 1, "remaining": 940 }
}

Two reading rules before you build logic on these fields. Treat impression as a reach band rather than a precise count, because the underlying platforms report ranges. And spend figures are always estimates, never advertiser-reported numbers, so phrase them that way in anything client-facing. Our ad spend estimator covers range-based spend inference if a client pushes back.

Store the API key in the header once and auth is done forever. Compare that with the Meta Marketing API integration dance to see why this setup section is one page instead of five. For the complete endpoint catalog beyond what these recipes use, see the full adlibrary API documentation guide.

Scenario 1: Competitor Watchlist Sweep

The workhorse of make.com ad spy automation. Every morning, pull every new ad your tracked competitors launched anywhere, and post the deltas to Slack before standup. This is the Make version of the diff-detection loop described in how to monitor competitor ads.

One-time setup. Resolve each brand with GET /api/advertisers/search?q=<brand>&country=US, which is free and returns the brand's Meta page IDs, Google advertiser IDs, and LinkedIn company IDs in one response. Save the brand via POST /api/advertisers with those IDs and record the returned UUID in a Google Sheet. One brand is rarely one account, and a saved advertiser holds all of them behind a single ID.

Module chain:

1. Schedule: daily at 06:10 (see Schedule a scenario)
2. Google Sheets > Search rows: reads the watchlist, outputs one bundle per brand
3. HTTP > Make a request: POST https://adlibrary.com/api/advertisers/{{advertiser_uuid}}/curate, empty JSON body
4. Iterator: map {{merge(3.meta.ads; 3.google.ads; 3.linkedin.ads)}} to fan all platforms into one per-ad stream
5. Data store > Get a record: key on {{4.ad_key}}
6. Filter: continue only when the record does not exist
7. Data store > Add/replace a record: write ad_key, advertiser, platform, first_seen
8. Slack > Create a message: advertiser, platform, ad copy snippet, landing page URL

The Data store is what turns a dumb fetch into a diff. On day one everything is new and Slack gets noisy. From day two onward, the only bundles that survive the filter are genuinely fresh creatives, and the channel becomes a launch radar your strategists actually read.

Credit cost: one curate call costs 1 credit per advertiser per 30-minute session, and it returns recent ads across all saved platforms in that single charge. Eight tracked competitors swept daily costs 8 credits a day. Cheap enough to run before anyone wakes up.

Scenario 2: Creative-Format Breakdown for a Dashboard Feed

Clients keep asking some version of "is our category shifting to video?" Answer it with a chart that updates itself. This scenario snapshots the format mix in a niche every day and appends it to a sheet that feeds a Looker Studio dashboard.

Module chain:

1. Schedule: daily at 07:00
2. HTTP > Make a request: POST /api/search with body:

{
  "keyword": "collagen supplement",
  "appType": "3",
  "geo": ["USA"],
  "daysBack": 30,
  "pageSize": 60
}

1. Iterator: map {{2.results}}
2. Array Aggregator: Group By set to {{3.ads_type}}
3. Iterator: map the aggregator's grouped output, one bundle per format group
4. Google Sheets > Add a row: date, format label, count, plus average heat and average days_count for the group

The Group By field on the Array Aggregator is the trick. It emits one collection per distinct ads_type value, each carrying its member ads, which turns sixty bundles into four rows: image, video, carousel, collection. Translate the numeric code into a label with Make's switch() function, as in {{switch(5.ads_type; 1; "image"; 2; "video"; 3; "carousel"; 4; "collection")}}.

Aggregate before you write. Sixty ads written row-by-row costs sixty Sheets operations a day and produces a table nobody can chart. Four grouped rows cost four operations and plot directly as a stacked area over time. After two weeks you have a defensible trend line on creative format share, average heat per format, and average runtime per format. That chart has carried more than one agency QBR, and pairs well with a competitive spending report when budgets come up.

Credit cost: 1 credit per day per tracked keyword. Two categories tracked for a month costs 60 credits.

Scenario 3: New-Advertiser Discovery by Keyword

Watchlists only cover competitors you already know. This scenario hunts the ones you don't: brands entering your client's category with fresh creative spend. It doubles as agency prospecting fuel, an angle covered deeper in ad intelligence for sales teams.

Module chain:

1. Schedule: weekly, Monday 06:30
2. HTTP > Make a request: POST /api/search with body:

{
  "keyword": "pet insurance",
  "appType": "3",
  "geo": ["USA", "GBR"],
  "sortField": "-first_seen",
  "daysBack": 7
}

1. Iterator: map {{2.results}}
2. Data store > Get a record: key on {{3.advertiser_name}}
3. Filter: record does not exist
4. Data store > Add/replace a record: advertiser name, first ad seen, platform, landing page domain
5. Text Aggregator: one digest line per new advertiser
6. Slack > Create a message: the weekly "new players" digest

Sorting by -first_seen puts the newest creatives at the top of the response, and the seven-day window keeps the search focused on genuinely recent activity. Keying the Data store on advertiser name instead of ad_key is deliberate. You don't care that an incumbent launched ad number 200. You care that a name you've never logged appeared at all.

The response's total field is a free bonus signal. Log it to a sheet each week and you get a market-activity index for the keyword, a rising or falling count of live ads in the category. Cross-reference new names against the Google Ads Transparency Center or the LinkedIn Ad Library when you want to confirm a finding by hand before it goes in front of a client. For deciding which discoveries deserve real research hours, the competitor ad monitoring setup guide has a prioritization rubric.

Credit cost: 1 credit per keyword per week. The cheapest scenario in the cookbook, and routinely the one that produces the "how did you spot them so early?" email.

Scenario 4: Enrichment Pipeline With a Router

Spotting a winning ad is the easy half. Explaining why it wins, in a brief your creative team can act on, is the half that eats afternoons. The AdLibrary API's AI enrichment endpoint runs that teardown per ad: a timestamped transcript, the strategic read, the persuasion analysis, and a 1:1 replication brief tuned to the detected format. This scenario feeds it automatically and routes the output by creative type.

Module chain:

1. Schedule: weekly, Friday 08:00
2. HTTP > Make a request: POST /api/search with body:

{
  "keyword": "meal kit delivery",
  "appType": "3",
  "sortField": "-heat_degree",
  "daysBack": 30
}

1. Iterator: map {{2.results}}
2. Filter: {{3.days_count}} >= 21 OR {{3.heat}} >= 700
3. HTTP > Make a request: POST https://adlibrary.com/api/enrichment with body:

{
  "ad": {
    "ad_key": "{{3.ad_key}}",
    "platform": "{{3.platform}}",
    "title": "{{3.title}}",
    "body": "{{3.body}}",
    "video_url": "{{3.video_url}}",
    "landing_page_url": "{{3.landing_page_url}}"
  }
}

1. Router: two routes with filters on {{3.ads_type}}
   • Route A (video, ads_type = 2): Google Docs > Insert a paragraph — transcript plus the UGC shoot script into the client's swipe doc
   • Route B (image, ads_type = 1): Google Sheets > Add a row — the generation prompt from the replication brief, ready for your image tooling

The filter at step 4 is the budget gate, and it encodes a real research principle. Runtime is the strongest public signal an ad converts, because advertisers kill losers fast, while heat catches fast risers that haven't aged into a runtime signal yet. Enriching only ads that clear one of those bars typically passes 5-10 ads per weekly run instead of 60. The Router then solves the format problem: a video teardown with a clip-by-clip script belongs in a doc humans read, while an image generation prompt belongs in a queue your tooling consumes. Each enrichment costs 1 credit for text and standard-length video, refunded if the analysis fails.

What lands in the doc is a creative brief a strategist would have spent an afternoon writing, produced while the team slept. The deeper workflow thinking behind brief-from-ad pipelines is in the creative strategist research workflow.

Scenario 5: Monthly Winners Report to Google Docs

The flagship deliverable. Once a month, for each tracked brand, scan their entire ad portfolio, score it, and compile the proven winners into a formatted document with evidence attached. Retainer clients renew on this report.

The winners endpoint does the analytical heavy lifting. POST /api/winners/advertiser/{page_id} fetches an advertiser's portfolio, dedupes near-identical variants into concepts, and scores each concept into tiers, surfacing the creatives the brand has clearly committed budget to. Each winner returns plain-language score.reasons like "Runtime 89 days, top 10% of this advertiser" and a dna_diff describing how the winner beat sibling ads pointing at the same landing page.

One-time setup. Resolve each brand's numeric Meta page ID with GET /api/winners/search-pages?q=<brand>&country=US, which is free. Confirm the returned page is the right brand with a sane ad_count before storing it, because a valid-but-wrong page ID returns real results and charges real credits.

Module chain:

1. Schedule: monthly, 1st at 05:00
2. Google Sheets > Search rows: brand list with confirmed page_id values
3. HTTP > Make a request: POST https://adlibrary.com/api/winners/advertiser/{{2.page_id}} with body {"country": "US"}
4. Iterator: map {{3.results}}
5. Filter: {{4.score.tier}} equals winner or high_confidence_winner
6. Text Aggregator: one formatted block per winner: advertiser, format, runtime, the reasons list, the dna_diff deltas
7. Google Docs > Create a document: title Winners Report — {{formatDate(now; "MMMM YYYY")}}, body from the aggregator

The Text Aggregator earns its place here. Without it you'd append paragraphs document-by-document across dozens of modules. With it, one Google Docs operation writes the whole report through the Docs API under the hood. Keep one detail in mind for multi-brand lists: winner scans run one at a time per account, so let the scenario process brands sequentially, which is Make's default behavior anyway.

Credit cost: a flat 10 credits per brand scan, auto-refunded when a scan returns empty or errors. Five tracked brands monthly costs 50 credits for what amounts to a senior analyst's week of portfolio review. Pitch teams run the same play ad hoc before new-business meetings, a pattern described in agency client pitch preparation.

Credit-Aware Scheduling: Budgeting Your Make.com Ad Spy Automation

Two meters run on every scenario: Make operations and AdLibrary credits. Both reward the same design instinct, doing less, less often, more deliberately.

Here's the full cookbook costed for a typical agency month:

That lands comfortably inside the Business plan's 1000+ monthly credits at €329/mo, with roughly 600 credits of headroom for ad hoc research and pitch-week spikes. Credits reset monthly without rollover, so unused allowance is forfeited allowance. If you end every month with 500 credits unspent, raise a cadence or add keywords rather than letting paid capacity evaporate. Treat the planning like media spend, and borrow the allocation logic from the ad budget planner.

Three scheduling rules keep the stack healthy:

• Respect the rate limit. The API allows 10 requests per minute per key. A watchlist of 30 brands fired in one burst will trip it. Offset scenario start times, and add a Sleep module between HTTP calls in high-volume loops. On a 429, the response carries a Retry-After header, and Make's error handlers with a Break directive can park and retry the bundle cleanly instead of failing the run.
• Schedule narrow and frequent over wide and rare. A daily 1-credit sweep catches creatives the morning they launch. A weekly 7-page mega-pull costs the same credits and hands you stale impressions data five days late.
• Filter before you spend. Searches cost credits whether or not you use the results, and failed searches refund automatically, but wasteful searches don't. Tight daysBack windows, specific keywords, and the runtime/heat gate from Scenario 4 are the difference between 400 and 900 credits for identical insight.

One more habit: map _credits.remaining from any search response into a Data store and alert yourself below a threshold. The balance check rides along free on every call.

Make vs n8n vs Zapier for This Job

Honest placement, since we've published cookbooks for all three. Make wins when the workflow is shaped like fan-out and fan-in, which describes most ad intelligence work, and its visual iterator-aggregator pairing is the cleanest of the trio. n8n wins when you want code nodes, self-hosting, and no per-operation anxiety at high volume. Zapier wins on app coverage and team familiarity but gets expensive fast when iterating arrays, since per-ad tasks multiply like Make operations at a higher unit price. The broader tooling landscape, including the AI-native entrants, is mapped in our marketing automation tools comparison.

If your team has outgrown visual builders entirely, the same API drives agentic workflows in Claude Code, and you can go as far as building your own MCP server over it. The Make recipes in this cookbook translate to those stacks almost line for line, because the underlying loop never changes. Search, iterate, filter, enrich, deliver.

Still weighing this against Make scenarios pointed at Meta's own surfaces? Our Make.com Meta ads automation recipes cover that adjacent territory, campaign operations rather than competitor intelligence, and the two cookbooks compose well.

Frequently Asked Questions

How many credits does a Make.com ad spy automation stack use per month?

A typical agency setup runs 350-450 credits monthly: a daily watchlist sweep of 8 competitors (240), daily format tracking on 2 keywords (60), weekly discovery on 3 keywords (12), a gated enrichment pipeline (40), and monthly winners scans on 5 brands (50). The Business plan's 1000+ monthly credits cover that with room for ad hoc research, and credits reset monthly without rollover.

Can I use Meta's free Ad Library API with Make instead?

Yes, and for political or social-issue ad transparency on Meta it's the right choice. For commercial competitor research it falls short: coverage is Meta-only, most commercial ad data is unavailable outside the EU and UK, and access requires app review plus tokens that expire every 60 days. Multi-platform commercial research in Make is far simpler against a paid API with one bearer key.

How do I handle the API's rate limit inside a Make scenario?

The limit is 10 requests per minute per key. Process bundles sequentially (Make's default), add a Sleep module between HTTP calls in loops that fire many requests, and offset the start times of scenarios sharing one key. If you do hit a 429, the response includes a Retry-After header, and a Make error handler with a Break directive can retry the bundle after the wait instead of failing the execution.

What's the difference between an iterator and an aggregator in these scenarios?

An iterator splits one bundle containing an array into many bundles, one per ad, enabling per-ad filters, lookups, and enrichment calls. An aggregator merges many bundles back into one, for grouped counts or a single digest message. Iterators multiply operations and aggregators contain them, so the cheapest scenarios iterate early, filter hard, and aggregate before writing to destinations.

Do I need to write code to build these five scenarios?

No. Every recipe uses Make's standard HTTP module with a JSON request body you can copy from this page, plus built-in modules for Sheets, Slack, Docs, data stores, and routing. Testing calls with curl before building is helpful but optional. If you later want code-level control, the same API works from any language or agent framework.

Ship the First Scenario This Week

Start with the watchlist sweep. It's the simplest chain, it produces visible value on day two, and every other recipe reuses its parts. Clone the HTTP module, point it at three competitors, and let the Data store start accumulating memory. Add the format breakdown once the Slack channel proves itself, then graduate to enrichment and winners reports as the team starts asking deeper questions.

The compounding effect is the point of make.com ad spy automation: each scenario's output makes the next one smarter, and none of them bill hours. A swipe file that fills itself, dashboards that update before standup, and a winners report that writes itself on the first of the month add up to a research function that runs while you sleep.

API access ships with the Business plan at €329/mo, including 1000+ monthly credits and free integration help, meaning the team will get on a call and wire these exact scenarios into your stack with you. Start at /features/api-access, or compare tiers on /pricing. The credits you'd spend testing all five recipes for a week cost less than the hour of manual research they replace on the first morning.