How to Monitor Competitor Ads in Google Ads Transparency Center

Google's Ads Transparency Center lets anyone see the ads an advertiser runs across Search, YouTube, Display, Shopping and Maps. It is a great research tool, but it has no alerts and no export, so keeping up with five competitors means clicking through five advertiser pages and trying to remember what you saw last week.

The Ads Transparency actor reads the same public ad library and returns one row per ad, with format, first and last shown dates, landing domain, media URLs and a link to the ad's page. Its monitoring mode remembers every ad it has delivered and only returns new ones on the next run, without charging for the rest.

This guide builds a daily competitor ad monitor: choosing how to identify competitors, setting filters, scheduling, sending new ads somewhere useful and analyzing the history.

Step by step

1. Decide how to identify each competitor

   You have three options. domains (for example nike.com) returns every ad Google shows for that domain, including ads placed by agencies and resellers. advertiserNames (for example HubSpot) matches the company name as shown in the Transparency Center and keeps all of a brand's legal entities. advertiserIds takes the AR… ID from an adstransparency.google.com/advertiser/AR… link and is the most precise. Domains are the easiest starting point; switch to IDs if a domain search pulls in advertisers you do not care about.

2. Narrow by market and format

   Use regions with two-letter country codes to keep only ads shown in your markets, and formats (text, image, video) if you only care about, say, video creatives. dateFrom and dateTo limit results to ads shown in a date window, useful for a first backfill. Leave filters empty to see everything.

3. Cap the volume per competitor

   maxAdsPerAdvertiser counts ads read newest first for each domain, name or ID, and maxResults caps the whole run. For a daily monitor a small per-advertiser cap such as 20 to 50 keeps runs fast and cheap, because new ads appear at the top of the list. Raise it once for an initial backfill if you want the history.

4. Switch on monitoring mode

   Set onlyNewSinceLastRun to true and choose a monitorName per watch list, for example uk-competitors. Every delivered ad is remembered in the key-value store ads-seen-<monitorName>, and later runs skip it at no charge. Decide whether you need includeDetails: it adds countries shown, impression ranges and best-effort headline and description text for $0.001 per ad, which is worth it for creative research but not essential for alerts.

   {
     "domains": ["competitor-one.com", "competitor-two.com"],
     "advertiserNames": ["HubSpot"],
     "regions": ["GB"],
     "formats": [],
     "maxAdsPerAdvertiser": 30,
     "maxResults": 500,
     "includeDetails": false,
     "onlyNewSinceLastRun": true,
     "monitorName": "uk-competitors"
   }

5. Schedule it daily

   Save the input as an Apify task and attach a schedule with a cron expression like 0 8 * * *. The first run returns the current set of ads up to your caps; from then on, each run returns only ads that appeared since. Add a webhook on run success that calls your own endpoint with the run's dataset ID.

6. Send new ads to Slack

   In the webhook handler, fetch the run's dataset and post a short summary to a Slack incoming webhook. Empty runs post nothing, so the channel only lights up when a competitor launches something.

   import os
   import requests
   
   # Called from your webhook handler with the finished run's dataset ID
   def post_new_ads(dataset_id: str, slack_webhook_url: str) -> None:
       items = requests.get(
           f"https://api.apify.com/v2/datasets/{dataset_id}/items",
           params={"clean": "true"},
           headers={"Authorization": f"Bearer {os.environ['APIFY_TOKEN']}"},
           timeout=60,
       ).json()
       if not items:
           return
       lines = [f"*{len(items)} new competitor ads*"]
       for ad in items[:20]:
           lines.append(f"{ad.get('advertiserName')} | {ad.get('format')} | "
                        f"{ad.get('landingDomain')} | {ad.get('previewUrl')}")
       requests.post(slack_webhook_url, json={"text": "\n".join(lines)}, timeout=30)
   

7. Analyze format mix and long-running creatives

   Once you have a backfill, load it into pandas to see each advertiser's format mix and which creatives have stayed live longest. Long-running ads are usually the ones a competitor keeps paying for, so they are a good place to start when studying their messaging.

   import os
   import pandas as pd
   from apify_client import ApifyClient
   
   client = ApifyClient(os.environ["APIFY_TOKEN"])
   run = client.actor("actor-forge/ads-transparency").runs().list(desc=True, limit=1, status="SUCCEEDED").items[0]
   ads = pd.DataFrame(client.dataset(run["defaultDatasetId"]).iterate_items())
   
   ads["firstShown"] = pd.to_datetime(ads["firstShown"])
   ads["lastShown"] = pd.to_datetime(ads["lastShown"])
   ads["daysLive"] = (ads["lastShown"] - ads["firstShown"]).dt.days
   
   # Format mix per advertiser
   print(ads.pivot_table(index="advertiserName", columns="format",
                         values="previewUrl", aggfunc="count", fill_value=0))
   
   # Long-running creatives are usually the ones that perform
   print(ads.sort_values("daysLive", ascending=False)
            [["advertiserName", "format", "daysLive", "landingDomain", "previewUrl"]]
            .head(20))
   

Sample input

{
  "domains": [
    "nike.com"
  ],
  "advertiserNames": [
    "HubSpot"
  ],
  "regions": [],
  "maxAdsPerAdvertiser": 20,
  "maxResults": 200,
  "includeDetails": false,
  "onlyNewSinceLastRun": true,
  "monitorName": "competitors-daily"
}

Sample output

Rows look like this, one per ad creative, with a link to the ad's own Transparency Center page:

Run it from code

cURL

curl -X POST "https://api.apify.com/v2/acts/actor-forge~ads-transparency/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["nike.com"], "advertiserNames": ["HubSpot"], "regions": [], "maxAdsPerAdvertiser": 20, "maxResults": 200, "includeDetails": false, "onlyNewSinceLastRun": true, "monitorName": "competitors-daily"}'

JavaScript (Node.js)

// Node.js 18+ (built-in fetch). Set APIFY_TOKEN in your environment.
const input = {
  "domains": [
    "nike.com"
  ],
  "advertiserNames": [
    "HubSpot"
  ],
  "regions": [],
  "maxAdsPerAdvertiser": 20,
  "maxResults": 200,
  "includeDetails": false,
  "onlyNewSinceLastRun": true,
  "monitorName": "competitors-daily"
};

const res = await fetch(
  "https://api.apify.com/v2/acts/actor-forge~ads-transparency/run-sync-get-dataset-items",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.APIFY_TOKEN}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(input),
  }
);
const items = await res.json();
console.log(items.length, items[0]);

Python

# pip install apify-client   (set APIFY_TOKEN in your environment)
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run_input = {
    "domains": [
        "nike.com"
    ],
    "advertiserNames": [
        "HubSpot"
    ],
    "regions": [],
    "maxAdsPerAdvertiser": 20,
    "maxResults": 200,
    "includeDetails": False,
    "onlyNewSinceLastRun": True,
    "monitorName": "competitors-daily"
}

run = client.actor("actor-forge/ads-transparency").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

The run-sync-get-dataset-items endpoint waits for the run (up to 5 minutes) and returns the dataset rows directly. For longer runs, start the run asynchronously and read the dataset when it finishes, as the Python example does. Replace APIFY_TOKEN with your own token from the Apify console.

What it costs

Ads cost $0.0006 each and details $0.001 each, so a first run of 100 ads is $0.06, or $0.16 with details. After that, a daily monitor that finds around 20 new ads costs about $0.012 a day, roughly $0.36 a month.

Tips and pitfalls

• There is no keyword search over ad text in the Transparency Center, so you cannot ask for all ads mentioning a phrase. Build your list from competitor domains and advertiser names instead.
• Many Google text ads are published only as a rendered image. Even with details on, expect some text ads to have a preview image and no headline text.
• Advertiser country is filled for advertiser-name searches only; domain and ID searches leave it empty.
• If Google shows a CAPTCHA or unusual-traffic page, the run stops early with the ads already delivered and says so in the status message. Blocked requests are free; just let the next scheduled run continue.
• Use separate monitorName values for separate watch lists so their seen-ads memories do not overlap.

FAQ

Actors used in this guide

Related guides

All guides