# Google Ads Transparency Scraper: Competitor Ads by Domain (`datagleaner/google-ads-transparency-scraper`) Actor Google Ads Transparency Center scraper: type a competitor's domain, brand name or advertiser ID and get its ads with format, first and last shown dates, countries, creative images and ad links. $1.50 per 1,000 ads, details included. No login, no browser. - **URL**: https://apify.com/datagleaner/google-ads-transparency-scraper.md - **Developed by:** [Data Gleaner](https://apify.com/datagleaner) (community) - **Categories:** Marketing, Lead generation, SEO tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing $1.50 / 1,000 ads This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## Google Ads Transparency Scraper: competitor ads by domain or advertiser **Type a competitor's domain or brand name and get the ads Google shows for it in the Ads Transparency Center: format, first and last shown dates, countries, creative images and a link to each ad.** One row per ad, as JSON, CSV or Excel. No login, no browser, no Google account. **$1.50 per 1,000 ads, with ad details included.** #### Why this one - **One flat price.** $0.0015 per ad. `includeDetails` (every creative variant and the countries where an ad ran) costs nothing extra. No start fee and no monthly rental. - **Search the way you think.** By competitor domain (`nike.com`), by company name (it picks the advertiser accounts with the most ads, up to 10 per name, because big brands run several), or by pasting an advertiser or ad page URL from adstransparency.google.com. - **Built to run from Apify's servers.** Google throttles a single IP after a few advertisers, so the Actor uses Apify Proxy datacenter IPs, spaces its requests and retries. Platform runs on 2026-10-11 returned ads for nike.com, adidas.com, shopify.com and notion.so. - **Only new ads, on a schedule.** Turn on `onlyNewAds`, run it daily, and you receive and pay for the ads that appeared since the last run. - **Honest about content.** You get ad metadata, `imageUrls` for image and text ads, and a `previewUrl` for video ads. Ad copy is not returned as text and video files are not downloaded (see Limits). #### Minimal input ```json {"domains": ["nike.com"], "region": "US", "maxAdsPerAdvertiser": 20} ``` An empty input runs the example domain `adidas.com`, capped at 5 ads. #### Sample output row A real row from a platform run on 2026-10-11 (domain search `shopify.com`, region US, `includeDetails` on, which adds `regions`, `variationCount` and `previewUrls`): ```json { "advertiserId": "AR01625195283841286145", "advertiserName": "Shopify Inc.", "creativeId": "CR06709085365593964545", "format": "text", "firstShown": "2024-03-18T00:25:58+00:00", "lastShown": "2026-10-11T05:46:47+00:00", "shownForDays": 937, "regions": [ { "region": "US", "lastShown": "2026-10-10" } ], "variationCount": 1, "imageUrls": [ "https://tpc.googlesyndication.com/archive/simgad/9011262948780097556" ], "landingDomain": "shopify.com", "adUrl": "https://adstransparency.google.com/advertiser/AR01625195283841286145/creative/CR06709085365593964545?region=US", "height": 180, "width": 348, "previewUrls": [], "region": "US", "input": "shopify.com", "scrapedAt": "2026-10-11T06:10:03+00:00" } ``` #### Price **$1.50 per 1,000 ads** ($0.0015 each). 20 ads cost $0.03; 5 advertisers with 400 ads each (2,000 ads) cost $3.00. Set a maximum charge on the run and it stops when the limit is reached. ### What you can do with it - **Competitor ad research:** see which Google ads a competitor has run, since when, and whether they are still live. - **Creative swipe files:** collect image creatives for a brand, filtered by format, region and date. - **Brand protection and compliance:** find who advertises pointing to your domain or under your brand name. - **Ad intelligence feeds:** schedule a daily run per advertiser with `onlyNewAds` on to get only the ads that are new since the last run. ### Input Give at least one advertiser ID, domain or search term. An empty input runs the example domain `adidas.com`, capped at 5 ads. ```json { "advertiserIds": ["AR16735076323512287233"], "domains": ["shopify.com"], "searchTerms": ["Spotify"], "region": "US", "startDate": "2026-01-01", "format": "any", "maxAdvertisersPerTerm": 3, "maxAdsPerAdvertiser": 100, "includeDetails": false, "onlyNewAds": false } ``` - `advertiserIds`: the `AR...` id, or an advertiser or ad page URL pasted from `adstransparency.google.com` (the id is taken from it). Returns that advertiser's ads. - `domains`: a website domain such as `nike.com`. Returns ads that point to that domain, from any advertiser. - `searchTerms`: a company or brand name, resolved through the site's search to the matching advertiser accounts with the most ads (accounts with no ads are skipped). `maxAdvertisersPerTerm` (default 3, max 10) sets how many accounts to scrape per term; big brands often run ads from several accounts. A domain typed here (`nike.com`) runs a domain search. - `maxAdsPerAdvertiser`: cap on ads for each advertiser ID, each domain and each advertiser account a search term resolves to (default 100, max 10000). Pages come in the order the site lists them, which is not strictly by date. - `region`: two-letter country code (US, GB, DE, JP, ...) or `anywhere` (default). `startDate` and `endDate` (YYYY-MM-DD) and `format` (`any`, `text`, `image`, `video`) filter the ads. - `includeDetails` (default false): one extra request per ad for all creative variants (more `imageUrls`, `previewUrls`, `variationCount`) and the regions where it ran, the requested region first. Slower, no extra charge. - `onlyNewAds` (default false): monitor mode, see below. - `requestDelaySeconds` (default 1.0) and `proxyConfiguration` (Apify Proxy by default) control pacing. ### Monitor mode Set `onlyNewAds` to true and schedule the Actor daily: each run returns only ads not delivered by an earlier run with `onlyNewAds` on, so you pay only for the new ones. Seen creative IDs are kept in a named key-value store, `google-ads-transparency-seen`, separately per advertiser or domain and per combination of region, format and dates. The first run returns everything up to the limit. ### Output One row per ad creative: ```json { "advertiserId": "AR16735076323512287233", "advertiserName": "Nike, Inc.", "creativeId": "CR06289851821125009409", "format": "image", "firstShown": "2023-11-17T11:19:29+00:00", "lastShown": "2026-10-07T09:20:38+00:00", "shownForDays": 1055, "region": "US", "regions": [{"region": "US", "lastShown": "2026-10-07"}], "variationCount": 1, "width": 300, "height": 250, "imageUrls": ["https://tpc.googlesyndication.com/archive/simgad/9542525759016532365"], "landingDomain": "nike.com", "previewUrls": [], "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR06289851821125009409?region=US", "input": "nike.com", "scrapedAt": "2026-10-07T12:00:00+00:00" } ``` `region` is the region you filtered on (or `anywhere`), and `adUrl` then opens the site filtered to it; `shownForDays` is how long the ad has run. A row only carries the fields the ad has, so there are no null columns: `regions` and `variationCount` are left out, and `previewUrls` is absent, unless `includeDetails` is on. `previewUrl`, `googleCustomerId`, `googleCreativeId`, `adGroupId` and `versionId` come from Google's preview URL, so they are left out when an ad has none (as with this image ad). `width` and `height` (pixels) are given for image ads only. The example above is abridged and shows a domain search with details on. Download the dataset as JSON, CSV, Excel or HTML, or read it through the API. ### Pricing Pay per result: **$1.50 per 1,000 ads** ($0.0015 per ad, event `ad`). Example: 5 advertisers with 400 ads each is 2,000 ads, about $3.00. Details cost nothing extra. A test run capped at 10 ads costs about $0.015. You can cap spend with the run's maximum total charge; the Actor stops when it is reached. ### Use with Python ```python ## pip install apify-client from apify_client import ApifyClient client = ApifyClient("YOUR_APIFY_TOKEN") run = client.actor("datagleaner/google-ads-transparency-scraper").call( run_input={"domains": ["nike.com"], "region": "US", "maxAdsPerAdvertiser": 10} ) for item in client.dataset(run.default_dataset_id).iterate_items(): print(item["advertiserName"], item["format"], item["lastShown"], item["adUrl"]) ``` ### Use with JavaScript / Node.js ```js // npm install apify-client import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: process.env.APIFY_TOKEN }); const run = await client.actor('datagleaner/google-ads-transparency-scraper').call({ domains: ['nike.com'], region: 'US', maxAdsPerAdvertiser: 10, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); for (const ad of items) console.log(ad.advertiserName, ad.format, ad.lastShown, ad.adUrl); ``` ### Use it from n8n, Make, Zapier or an AI agent Actor ID: `datagleaner/google-ads-transparency-scraper` Minimal input: ``` {"domains": ["nike.com"], "region": "US", "maxAdsPerAdvertiser": 10} ``` Each tool below runs this Actor with your own Apify API token. - **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`). On n8n Cloud you install it from the community node registry. Choose **Run an Actor and get dataset**, set Actor to `datagleaner/google-ads-transparency-scraper` and paste the input above. - **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to read the results. **Watch Actor Runs** can trigger a scenario when a run finishes. - **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**. The trigger **Finished Actor run** starts a Zap when a run ends. - **AI agents (MCP):** connect to `https://mcp.apify.com?tools=datagleaner/google-ads-transparency-scraper`. In Claude Code: ``` claude mcp add --transport http apify "https://mcp.apify.com?tools=datagleaner/google-ads-transparency-scraper" ``` Then run `/mcp` to sign in to Apify in your browser, or send the header `Authorization: Bearer YOUR_APIFY_TOKEN`. Then ask in plain words, for example: > Find the Google ads Shopify has run in the US since July, up to 20, and list each one's format, first and last shown dates and ad link. - **LangChain (Python):** ```python ## pip install langchain-apify, then set APIFY_TOKEN in your environment import json from langchain_apify import ApifyActorsTool tool = ApifyActorsTool("datagleaner/google-ads-transparency-scraper") result = tool.invoke({"run_input": json.loads('{"domains": ["nike.com"], "region": "US", "maxAdsPerAdvertiser": 10}')}) ``` ### Monitor mode: only new ads Turn on `onlyNewAds` and schedule the Actor (daily is typical) to receive just the ads that appeared since the last run, and pay only for those. - The Actor keeps a named key-value store, `google-ads-transparency-seen`, with one entry per advertiser or domain and the same region, format and dates. Each entry holds the `creativeId`s already delivered and the date of the last complete run. - The first run delivers up to `maxAdsPerAdvertiser` ads and sets that date. - Later runs deliver an ad only if it was never delivered and was first shown on or after the stored date (with one day of slack). Long-running ads that you already have, and old ads that were never delivered, are skipped and not charged. - The site does not list ads by age, so the Actor does not stop at the first known ad. It keeps paging until it reaches `maxAdsPerAdvertiser`, the end of the list, or five pages in a row with nothing new. - If more than `maxAdsPerAdvertiser` new ads appear between two runs, the extra ones are skipped for good, because the date moves forward after each complete run. Raise the limit or run more often for very active advertisers. - Only ads that were delivered and charged are remembered. If a run stops early (your maximum total charge, or Google throttling), the date stays where it was, so the next run picks up the rest without charging twice. ### FAQ **Can I use the Google Ads Transparency Center as an API?** Yes, through this Actor: call it from the Apify API, the Python or JavaScript client, or MCP, and get the ads back as JSON. **How do I see a competitor's Google ads?** Put their domain in `domains` or their company name in `searchTerms` (it picks the accounts with the most ads, default 3). You get the ads the Transparency Center shows for them, with first and last shown dates and image creatives. **How do I find an advertiser ID?** Use `searchTerms` with the company name, or paste the advertiser's page URL into `advertiserIds`. **Do I need a Google account?** No. The data is public and the Actor needs no login. **Why fewer ads than the site shows?** Region, date and format filters and `maxAdsPerAdvertiser` apply, and duplicates are removed by `creativeId`. ### Limits - Ad copy is not returned as text. Google archives most text and image ads as rendered images, which `imageUrls` holds; the rest, video ads included, have `previewUrl`, Google's preview script for that creative. Video files and impression ranges are not exposed. - `landingDomain` is only filled for domain searches. - Google throttles a single IP that sends many requests quickly, so the Actor uses Apify Proxy (datacenter) by default, paces its requests and retries. Without a proxy, expect throttling after a few advertisers. - Results come in the order the site lists them, which is not strictly by date. The region filter uses country-level codes. ### Responsible use This Actor reads public transparency data that Google publishes for anyone. Advertiser names can be individuals; if you store or process personal data, your own data-protection obligations apply. # Actor input Schema ## `advertiserIds` (type: `array`): Advertiser IDs such as AR16735076323512287233, or advertiser or ad page URLs pasted from adstransparency.google.com (the AR... id is taken from them). Returns that advertiser's ads. ## `domains` (type: `array`): Website domains such as nike.com. Returns ads that point to that domain, from any advertiser. ## `searchTerms` (type: `array`): Company or brand names. Each is resolved to the matching advertiser accounts with the most ads (accounts with no ads are skipped), then their ads are returned. A domain typed here (nike.com) runs a domain search. ## `maxAdvertisersPerTerm` (type: `integer`): How many matching advertiser accounts to scrape for each search term, most ads first. Big brands often run ads from several accounts (one per country). ## `maxAdsPerAdvertiser` (type: `integer`): Upper bound on ads for each advertiser ID, domain and resolved search term. In the site's order, which is not strictly by date. ## `region` (type: `string`): Two-letter country code (US, GB, DE, JP, ...) to only return ads shown there, or 'anywhere'. ## `startDate` (type: `string`): Only ads shown on or after this date (YYYY-MM-DD). ## `endDate` (type: `string`): Only ads shown on or before this date (YYYY-MM-DD). ## `format` (type: `string`): Restrict to one ad format. ## `includeDetails` (type: `boolean`): Fetches each ad's detail record: all creative variants (more imageUrls, variationCount) and the regions where it was shown with the last date per region. One extra request per ad (4 at a time), so runs are slower. No extra charge. ## `onlyNewAds` (type: `boolean`): Return only ads not delivered by an earlier run with onlyNewAds on. Remembers delivered creative IDs and the date of the last complete run in a named key-value store (google-ads-transparency-seen) per advertiser or domain and the same region, format and dates. Delivers an ad only if it is new and was first shown since that date; new ads beyond the ad limit in one interval are skipped. Schedule the Actor daily to track new ads; you pay only for the new ones. ## `requestDelaySeconds` (type: `number`): Base pause between requests; the actual pause is randomised up to 1.5x. Raise it if Google starts rate limiting. ## `proxyConfiguration` (type: `object`): Apify Proxy (datacenter) by default: Google throttles a single IP after a few advertisers. ## Actor input object example ```json { "domains": [ "nike.com" ], "maxAdvertisersPerTerm": 3, "maxAdsPerAdvertiser": 100, "region": "anywhere", "format": "any", "includeDetails": false, "onlyNewAds": false, "requestDelaySeconds": 1, "proxyConfiguration": { "useApifyProxy": true } } ``` # Actor output Schema ## `results` (type: `string`): No description # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "domains": [ "nike.com" ], "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("datagleaner/google-ads-transparency-scraper").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "domains": ["nike.com"], "proxyConfiguration": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("datagleaner/google-ads-transparency-scraper").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "domains": [ "nike.com" ], "proxyConfiguration": { "useApifyProxy": true } }' | apify call datagleaner/google-ads-transparency-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,datagleaner/google-ads-transparency-scraper" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/JduCcsU25rl4EcLIe/builds/kJjSbpPMgEJluAi1b/openapi.json