# Google Ads Scraper (`automation-lab/google-ads-scraper`) Actor Scrape Google Ads Transparency Center ads by advertiser, domain, ID or link in any country. Filter by platform (Search, YouTube, Shopping, Maps, Play), format and date. Get creatives, shown dates, optional impressions per ad, and landing domains on domain searches. - **URL**: https://apify.com/automation-lab/google-ads-scraper.md - **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community) - **Categories:** Marketing, Lead generation - **Features:** Limited permissions, Multi-tenant, Server interface - **Stats:** 932 total users, 159 monthly users, 99.8% runs succeeded, 7 bookmarks - **User rating**: 5.00 out of 5 stars ## Pricing from $1.00 / 1,000 ad scrapeds This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. 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 Scraper Scrape ads from the [Google Ads Transparency Center](https://adstransparency.google.com/) at scale. Search by advertiser name, domain, or advertiser ID in any country. Get every creative with its format, first/last shown dates, days shown, landing domain, media, and a direct Transparency Center link — plus, optionally, the countries each ad ran in and Google's published impression ranges. Pure HTTP, no browser. Export to JSON, CSV, Excel, or feed directly into your tools. ### 🔍 What does Google Ads Scraper do? This actor searches the Google Ads Transparency Center and extracts structured data from every ad it finds. It uses Google's internal RPC API directly — no browser, no Playwright, no Puppeteer — making it fast and resource-efficient (512 MB default memory, usually 10–20 seconds per advertiser). Search for advertisers by name, look up ads by domain, or pass advertiser IDs directly. Optionally narrow results by country with `region` (any ISO country code), by creative format with `adFormats`, and by an inclusive shown-date window with `shownAfter` and `shownBefore`. Turn on `includeRegionStats` to add the countries each ad was shown in and per-country impression ranges. The actor returns clean, flat records ready for spreadsheets, databases, or any downstream workflow. ### Who is it for? Google Ads Scraper is built for teams that need repeatable Google Ads Transparency Center data without manually searching advertiser pages. It is the Google source in a cross-channel ad monitoring workflow alongside Meta/Facebook and LinkedIn ad library scrapers. ### Automated market research workflow on Apify Use this actor as one source in a broader competitor-intelligence and market-research workflow: 1. **Monitor ads and messaging** with [Google Ads Scraper](https://apify.com/automation-lab/google-ads-scraper), [Google Ads Transparency Center Scraper](https://apify.com/automation-lab/google-ads-transparency-center-scraper), and [LinkedIn Ad Library Scraper](https://apify.com/automation-lab/linkedin-ad-library-scraper). 2. **Track reviews and sentiment** with [G2 Reviews & Products Scraper](https://apify.com/automation-lab/g2-scraper), [Trustpilot Reviews Scraper](https://apify.com/automation-lab/trustpilot), and [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper). 3. **Watch demand and category trends** with [Google Trends Scraper](https://apify.com/automation-lab/google-trends-scraper), [Google News Scraper](https://apify.com/automation-lab/google-news-scraper), and [TikTok Trends Scraper](https://apify.com/automation-lab/tiktok-trends-scraper). 4. **Benchmark ecommerce pricing and products** with [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper), [Google Shopping Scraper](https://apify.com/automation-lab/google-shopping-scraper), and [Shopify Store Scraper](https://apify.com/automation-lab/shopify-scraper). 5. **Map companies to people** with [LinkedIn Company Employees Scraper](https://apify.com/automation-lab/linkedin-company-employees-scraper) when you need account or team context. Schedule runs, export datasets to CSV/Excel/JSON, or connect the outputs to Google Sheets, webhooks, Make, Zapier, BI tools, and LLM reporting workflows. ### 👥 Who is Google Ads Scraper for? - **Digital marketers** — Research competitor ad strategies across Google Search, YouTube, and Display Network. See what creatives they run and when. - **Competitive intelligence teams** — Monitor which advertisers are active in your market, track new campaigns, and benchmark ad formats. - **Brand protection specialists** — Detect unauthorized advertisers using your brand name or domain in Google Ads. - **Media buyers & agencies** — Audit competitor ad presence, discover creative inspiration, and report on market activity. - **Researchers & journalists** — Analyze advertising transparency data at scale for reporting and academic research. - **Ad verification professionals** — Verify advertiser identity, check verification status, and track ad history. ### ⚡ Why use Google Ads Scraper? | Feature | Google Ads Scraper | |---------|-------------------| | **Pricing** | $1.00 per 1,000 ads on every plan, plus $0.005 per run that returns ads | | **Search by advertiser name, domain, advertiser ID, or Transparency Center link** | ✅ All four, combined in one run | | **Country filter** | ✅ Every country, by ISO code or name (US, GB, Germany, Australia, …) | | **Platform filter** | ✅ Google Search, YouTube, Google Shopping, Google Maps or Google Play | | **Format and shown-date filters** | ✅ Text / Image / Video, inclusive date window | | **Countries shown + impression ranges** | ✅ Optional `includeRegionStats`, same price per ad | | **Days shown, Transparency Center link** | ✅ In every record | | **Landing domain** | ✅ On domain searches (Google omits it for advertiser searches) | | **Technology** | Pure HTTP, no browser, 512 MB | **Key advantages:** - 💰 **Pay only for results** — $1 per 1,000 ads. Runs that find no ads, or have invalid input, are not charged at all. - 🚀 **Pure HTTP, no browser** — Direct API calls mean low memory, fast execution, and low compute cost. - 🔎 **Four ways to search** — Advertiser name, website domain, direct advertiser ID, or a pasted Transparency Center advertiser or domain link. - 🏷️ **Finds the real advertiser** — A brand search picks the largest advertisers whose name contains the term, so "Nike" returns Nike, Inc. and Nike Retail BV, not one-ad accounts with similar names. - 📺 **Filter by platform** — Only ads shown on Google Search, YouTube, Google Shopping, Google Maps or Google Play, using Google's own filter. - ♻️ **No duplicates across inputs** — A creative found by both a domain and its advertiser is delivered and charged once. - 🌍 **Any country** — Filter ads shown in a specific country with its ISO code. An unknown code fails fast with a clear message instead of returning an empty dataset. - 📍 **Where an ad ran** — `includeRegionStats` adds every country the creative was shown in, per-country first/last shown dates, and the impression ranges Google publishes (mainly for EU/UK countries). - 🎯 **Campaign-ready filters** — Select Text, Image, or Video with `adFormats`, then use `shownAfter` and `shownBefore` for an inclusive shown-date window. ### 📊 What data can you extract? | Field | Type | Description | |-------|------|-------------| | `advertiserId` | string | Unique Google Ads advertiser ID | | `advertiserName` | string | Name of the advertiser | | `isVerified` | boolean | Whether the advertiser is verified by Google | | `creativeId` | string | Unique ID for the specific ad creative | | `adFormat` | string | Format of the ad: Text, Image, or Video | | `firstShown` | string | Date the ad was first shown (YYYY-MM-DD) | | `lastShown` | string | Date the ad was last shown (YYYY-MM-DD) | | `daysShown` | integer | null | Number of days Google reports the creative as shown | | `landingDomain` | string | null | Landing domain of the ad (for example `nike.com`), when Google lists it — always for domain searches | | `adUrl` | string | Link to the creative's page in the Google Ads Transparency Center | | `previewUrl` | string | null | Google's creative preview script URL, when available | | `imageUrl` | string | null | Primary direct image URL when available | | `adText` | string | null | Available primary ad copy normalized from the creative preview | | `headline` | string | null | Ad headline or product title when Google exposes it | | `body` | string | null | Ad body when Google exposes it (rare; usually null) | | `callToAction` | string | null | CTA label when Google exposes it (rare; usually null) | | `destinationUrl` | string | null | Full landing URL when Google exposes it (rare; usually null — use `landingDomain`) | | `mediaUrls` | array | Direct image, poster, or other creative media URLs found | | `region` | string | Requested ISO country code, or `all` | | `regionStatsStatus` | string | With `includeRegionStats`: `ok`, `skipped` (no time left for the lookup) or `unavailable` (Google lookup failed); region fields are `null` unless `ok` | | `shownCountries` | array | null | With `includeRegionStats`: ISO codes of every country where the ad was shown | | `regionStats` | array | null | With `includeRegionStats`: per country `region`, `impressionsMin`, `impressionsMax`, `firstShown`, `lastShown` | | `impressionsMin` / `impressionsMax` | integer | null | With `includeRegionStats`: Google's total impressions range, where published (mainly EU/UK) | ### 💰 How much does it cost to scrape Google Ads? Google Ads Scraper uses [pay-per-event pricing](https://docs.apify.com/platform/actors/running/pay-per-event). You only pay for what you use — no monthly subscriptions, no minimums. | Charge event | Price (Bronze) | Description | |-------------|---------------|-------------| | **Run started** | $0.005 | One-time charge per run, only when the run returns at least one ad | | **Ad scraped** | $0.001/ad | Per ad extracted | **From 2026-11-24 the per-ad price changes:** Free and Bronze $0.0013, Silver $0.00117, Gold and above $0.00104. The $0.005 start fee stays the same. The current per-ad price is the same on every Apify plan: | Plan | Per-ad price | Discount | |------|-------------|----------| | Free | $0.001 | Same price | | Bronze (Starter) | $0.001 | Same price | | Silver (Scale) | $0.001 | Same price | | Gold (Business) | $0.001 | Same price | | Platinum (Enterprise) | $0.001 | Same price | | Diamond (Enterprise+) | $0.001 | Same price | **Cost examples (one run, start fee included):** | Ads per run | This actor (all plans) | |-------------|------------------------| | 100 ads | **$0.105** | | 1,000 ads | **$1.005** | **Comparison with similar pay-per-ad actors** (Apify Store prices checked 2026-11-09; one run of 1,000 ads, start fee included, default memory): | Actor | Free | Bronze | Silver | Gold and above | |-------|------|--------|--------|----------------| | This actor | $1.005 | $1.005 | $1.005 | $1.005 | | lexis-solutions/google-ads-scraper | $1.48 | $1.24 | $1.00 | $0.77 | | solidcode/ads-transparency-scraper | $1.50 | $1.00 | $0.90 | $0.80 | On the Free plan this actor is about a third cheaper; on Bronze and Silver prices are about the same; on Gold and above these two competitors are cheaper per ad. Prices change; check each actor's Store page for current numbers. ### 🚀 How to scrape Google Ads 1. Go to [Google Ads Scraper](https://apify.com/automation-lab/google-ads-scraper) on Apify Store. 2. Click **Try for free** to open the actor in Apify Console. 3. Enter advertiser names (e.g., "Nike", "Apple"), domains (e.g., "nike.com"), advertiser IDs, or Transparency Center links. 4. Optionally select the platform, ad formats, an inclusive shown-date window, the region, and max matching ads per advertiser. 5. Click **Start** and wait for the run to finish. 6. Download your data as JSON, CSV, Excel, or connect to any integration. ### ⚙️ Input parameters | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `searchTerms` | array of strings | — | Advertiser names to search for (e.g., "Nike", "Apple", "Coca-Cola"). Uses the largest advertisers whose name contains the term | | `domains` | array of strings | — | Website domains to look up (e.g., "nike.com", "www.apple.com"; full links work too) | | `advertiserIds` | array of strings | — | Direct advertiser IDs (e.g., "AR16735076323512287233") | | `startUrls` | array | — | Transparency Center advertiser or domain links. A `region` or `platform` in the link overrides the filters below. Links to one creative are skipped | | `region` | string | `""` (all) | Two-letter ISO country code or country name of any country (e.g., "US", "GB", "Germany", "Australia") | | `platform` | string | `""` (all) | Only ads shown on `SEARCH`, `YOUTUBE`, `SHOPPING`, `MAPS` or `PLAY` | | `adFormats` | array of strings | `[]` (all) | Creative formats to include: `Text`, `Image`, and/or `Video` | | `shownAfter` | string | `""` (unbounded) | Include creatives whose shown interval overlaps this date or later (`YYYY-MM-DD`) | | `shownBefore` | string | `""` (unbounded) | Include creatives whose shown interval overlaps this date or earlier (`YYYY-MM-DD`) | | `maxAds` | integer | `100` | Maximum number of matching ads to scrape per advertiser or domain (1–1,000) | | `maxAdvertisersPerTerm` | integer | `10` | How many advertisers to scrape for each search term, largest first (1–100). Each can return up to `maxAds` ads | | `includeRegionStats` | boolean | `false` | Add `shownCountries`, `regionStats`, and impression ranges (one extra request per ad; same price) | `shownAfter` and `shownBefore` define an inclusive shown-date window: a creative is included when its `firstShown`–`lastShown` interval overlaps the requested window. The actor keeps paging until it collects `maxAds` matching creatives per advertiser or Google has no more results. Filtered-out rows are not charged. **Tip**: You must provide at least one search term, domain, advertiser ID, or start URL. You can use them together in a single run — results from all sources are combined into one dataset. Omitting `adFormats`, `shownAfter`, and `shownBefore` preserves the existing unfiltered behavior. ### 📦 Output example ```json { "advertiserId": "AR16735076323512287233", "advertiserName": "Nike, Inc.", "isVerified": true, "creativeId": "CR05122336859459944449", "adFormat": "Image", "firstShown": "2025-10-22", "lastShown": "2026-11-02", "daysShown": 252, "landingDomain": "nike.com", "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR05122336859459944449", "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?...", "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/16995825365890857401", "adText": null, "headline": null, "body": null, "callToAction": null, "destinationUrl": null, "mediaUrls": ["https://tpc.googlesyndication.com/archive/simgad/16995825365890857401"], "region": "all", "regionStatsStatus": "ok", "shownCountries": ["CY", "GB", "GR", "US"], "impressionsMin": 1000000, "impressionsMax": 1250000, "regionStats": [ { "region": "GR", "impressionsMin": 1000, "impressionsMax": 2000, "firstShown": "2025-10-23", "lastShown": "2026-11-01" }, { "region": "US", "impressionsMin": null, "impressionsMax": null, "firstShown": null, "lastShown": "2026-11-02" } ] } ``` The last five fields appear only with `includeRegionStats: true`. `regionStatsStatus` says whether the region fields are known: - `ok` — the region fields are Google's data (an empty list means Google listed no countries). - `skipped` — the run was close to its time limit, so this ad was saved without a region lookup. Region fields are `null`, not empty. The run's status message says how many ads were skipped. Re-run with a longer timeout or a lower `maxAds` to get them. - `unavailable` — Google's lookup failed for this ad. Region fields are `null`. ### 💡 Tips for best results - **Use specific names** — Searching "Nike" is better than "shoes." Specific advertiser names yield more accurate matches. A popular brand can return `maxAds` per advertiser for up to 10 advertisers; lower `maxAdvertisersPerTerm` to cap it. - **Search by domain for precision** — If you know the advertiser's website, domain search gives exact matches without ambiguity. - **Use advertiser IDs for repeat monitoring** — Once you know the ID, future runs skip the search step and go directly to ad collection. - **Set region for local insights** — Use ISO country codes or country names (US, GB, Germany, Japan, etc.) to see which ads run in specific markets. - **Filter by platform** — Set `platform` to YouTube, Search, Shopping, Maps or Play to study one channel at a time; each row then carries a `platform` value. - **Target active campaign slices** — Combine `adFormats` with `shownAfter` and `shownBefore` to collect only creatives that overlap your reporting period. - **Start with low maxAds** — Use 20–50 for initial exploration, then increase to 500–1,000 for full audits. - **Combine search modes** — Use names + domains + IDs in one run to cover all angles of a competitive landscape. - **Schedule regular runs** — Set up daily or weekly schedules to track new ad creatives over time. ### Runtime limits and data handling Each Google request has a bounded 12-second attempt budget. The Actor reserves 25 seconds for saving results and cleanup, and starts another request only when that attempt fits before the reserve. A 60-second run can therefore attempt a small lookup; larger searches should keep the default 300-second timeout. Retries and upstream availability can still exhaust short runs. Partial results are preserved; an operational failure with no results remains a failed run, while a successfully queried no-match can return an empty dataset. The Actor itself uses no AI or external model provider. MCP clients may independently process exported results; their handling is controlled by the client, not this Actor. Google receives the requested public advertiser names, IDs, domains and filters. Apify provides execution, storage and optional managed proxy routing; those operating costs are borne by the publisher and covered by the documented start/ad events, with no separate third-party subscription or customer credential required. Session cookies stay in memory for the run and are not written to output. Dataset records contain public advertising content, advertiser identifiers and media links; logs can include requested target identifiers and operational errors. Do not supply credentials, confidential queries or sensitive personal data. Input, results and logs remain in Apify storage according to your account's retention settings until expiry or deletion; the Actor does not create a named cross-run cache. Failed operations send sanitized diagnostic input, exceptions, and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed; diagnostic reports are retained for 30 days. Delete run storage in Console/API when no longer needed, and review [Apify's privacy policy](https://apify.com/privacy-policy) and [Google's privacy policy](https://policies.google.com/privacy) for their data handling. Use results lawfully and minimize downstream personal-data retention. Automation Lab is independent of Google and Apify; product names identify the data source and platform, not endorsement or affiliation. Standard Apify Store terms apply. For support, use this Actor's Issues tab in Apify Console. ### Use with Claude AI (MCP) This actor is available as a tool in Claude AI through the Model Context Protocol (MCP). Add it to Claude Desktop, Cursor, Windsurf, or any MCP-compatible client. #### Setup for Claude Code ```bash claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/google-ads-scraper" ``` #### Setup for Claude Desktop, Cursor, or VS Code Add this to your MCP config file: ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com?tools=automation-lab/google-ads-scraper" } } } ``` #### Example prompts - "Find all Google Ads currently running for Nike in the US and describe their creative formats" - "Search the Google Ads Transparency Center for ads by apple.com and show me the most recent ones" - "Which advertisers in the fitness industry are running the most ads on Google right now?" Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp). ### 🔗 Integrations Connect Google Ads Scraper to your existing tools: - **Google Sheets** — Automatically export scraped ads to a spreadsheet for team review. - **Slack** — Get notifications when new competitor ads are detected. - **Airtable** — Build a competitive ad library with images and metadata. - **Zapier / Make / n8n** — Trigger downstream workflows when new ads are found. - **Webhooks** — Send results to your own API endpoint for custom processing. - **Google BigQuery / Snowflake** — Load ad data into your data warehouse for trend analysis. #### Example workflows - **Cross-channel ad monitoring**: Run this actor for Google Ads Transparency Center data, [Facebook Ads Library Scraper](https://apify.com/automation-lab/facebook-ads-library) for Meta/Facebook and Instagram ads, and [LinkedIn Ad Library Scraper](https://apify.com/automation-lab/linkedin-ad-library-scraper) for B2B ads. Export all three datasets to Sheets, Airtable, BigQuery, or a warehouse and compare new creatives by advertiser, date, region, and platform. - **Competitor monitoring**: Schedule daily runs with competitor advertiser names. Compare new ads against previous runs to spot new campaigns and creative changes. - **Ad creative research**: Search for major brands in your industry to build a library of ad inspiration across Text, Image, and Video formats. - **Brand protection**: Search for your brand name and domain to detect unauthorized advertisers running ads with your trademarks. - **Market research**: Compare the same advertiser's ads across different regions to understand localization strategies. ### Use this Actor in n8n Prefer building workflows in n8n? Install our community node to run this Actor directly from n8n without writing Apify API code. Use the n8n node to schedule competitor-ad checks and send new Google Ads creatives to Slack, Sheets, Airtable, or your reporting database. - n8n package: [`n8n-nodes-apify-google-ads-scraper`](https://www.npmjs.com/package/n8n-nodes-apify-google-ads-scraper/v/0.1.0) - Works with your Apify API token and existing Apify credits - Useful for scheduled workflows, competitor-ad alerts, reporting, and spreadsheet/database exports See the npm README for installation steps and example n8n workflows. ### API usage Use the Apify API to run Google Ads Scraper from your own applications, scheduled jobs, or data pipelines. ### 🤖 Using the Apify API You can start and retrieve results programmatically using the [Apify API](https://docs.apify.com/api/v2). #### Node.js ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_API_TOKEN' }); const run = await client.actor('automation-lab/google-ads-scraper').call({ searchTerms: ['Nike'], region: 'US', maxAds: 100, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items); ``` #### Python ```python from apify_client import ApifyClient client = ApifyClient('YOUR_API_TOKEN') run = client.actor('automation-lab/google-ads-scraper').call(run_input={ 'searchTerms': ['Nike'], 'region': 'US', 'maxAds': 100, }) items = client.dataset(run['defaultDatasetId']).list_items().items print(items) ``` #### cURL ```bash ## Start a run curl -X POST "https://api.apify.com/v2/acts/automation-lab~google-ads-scraper/runs?token=YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{"searchTerms": ["Nike"], "region": "US", "maxAds": 100}' ## Get results (replace DATASET_ID with the actual dataset ID from the run) curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN" ``` ### ⚖️ Is it legal to scrape Google Ads Transparency Center? The [Google Ads Transparency Center](https://adstransparency.google.com/) is a **public transparency tool** created by Google to provide public access to ads running across Google's advertising platforms. It was launched to meet regulatory requirements and promote ad transparency. - The Ads Transparency Center is publicly accessible without any login. - All data is intentionally made public by Google for transparency purposes. - This actor accesses only publicly available data from the Transparency Center. Always review and comply with Google's [Terms of Service](https://policies.google.com/terms) and applicable laws in your jurisdiction before using this actor. ### ❓ FAQ **Q: How many ads can I scrape per run?** Up to 1,000 ads per advertiser or domain (set via `maxAds`). A search term covers up to 10 advertisers by default (`maxAdvertisersPerTerm`), and each one can return up to your `maxAds` limit. Set a **Maximum charge per run** to cap the spend; the run stops at it. **Q: What ad formats are supported?** The actor extracts Text, Image, and Video ads from the Google Ads Transparency Center. Set `adFormats` to one or more of those values to return only the selected formats; omit it to keep all formats. **Q: How do the shown-date filters work?** Set `shownAfter`, `shownBefore`, or both as `YYYY-MM-DD`. The bounds are inclusive, and a creative matches when its `firstShown`–`lastShown` interval overlaps the requested window. Omit both fields to keep the existing date-unfiltered behavior. **Q: Can I search by domain?** Yes. Enter website domains (e.g., "nike.com") in the `domains` field. The actor looks up the advertiser associated with that domain and scrapes their ads. **Q: Do I need a Google account?** No. The Google Ads Transparency Center is publicly accessible. No login or authentication is needed. **Q: What regions are supported?** All countries available in the Google Ads Transparency Center. Use ISO country codes (e.g., "US", "GB", "DE", "FR", "JP", "BR", "IN"). Leave empty to get ads from all regions. **Q: How fast is it?** Each advertiser usually takes 10–20 seconds. With `includeRegionStats`, expect about 1 minute per 100–200 ads, so the default 5-minute timeout covers roughly 400 ads with region details. For larger runs, raise the run timeout (for example 900 seconds for 1,000 ads). If time runs short, ads are still saved and marked `regionStatsStatus: "skipped"`. The actor runs on 512 MB memory with pure HTTP calls — no browser startup overhead. **Q: Why are some fields null?** Google exposes different detail levels by creative format. The actor fills copy, headline, body, CTA, destination, and media fields only when those values are present in Google's response; it never guesses them. Direct-image creatives may have media but no text, while Shopping-style previews often expose a product headline and image. Some newer ads may not yet have `lastShown` populated. **Q: Does Google publish impressions?** Google publishes impression ranges mainly for ads shown in EU/UK countries. With `includeRegionStats`, the actor returns them where Google does, and `null` elsewhere — it never invents numbers. The list of countries where an ad ran (`shownCountries`) is available for all ads. **Q: The actor returned 0 ads. What should I do?** - Verify the advertiser exists on the [Google Ads Transparency Center](https://adstransparency.google.com/) directly. - Try a different search term or check the spelling. - If using a domain, make sure the domain is associated with a Google Ads advertiser. ### Legality Scraping publicly available data is generally legal according to the [US Court of Appeals ruling](https://en.wikipedia.org/wiki/HiQ_Labs_v._LinkedIn) (HiQ Labs v. LinkedIn). This actor only accesses publicly available information and does not require authentication. Always review and comply with the target website's Terms of Service before scraping. For personal data, ensure compliance with GDPR, CCPA, and other applicable privacy regulations. ### How do I monitor competitor Google Ads campaigns automatically? To set up ongoing competitive ad intelligence, schedule the scraper to run daily or weekly against your competitor list: 1. Run the scraper once with competitor names and domains to discover their Google advertiser IDs. 2. Save those IDs — future runs using `advertiserIds` skip the search step and go straight to ad collection, making them faster and more reliable. 3. Schedule daily runs and export results to a database or Google Sheet with a timestamp column. 4. On each run, compare new `creativeId` values against your previous dataset to identify new ad creatives. 5. Track `firstShown` and `lastShown` dates to understand campaign cadence — how frequently do competitors rotate creatives? How long do specific ads run? This workflow reveals competitor ad activity patterns without needing access to their ad accounts. You can detect when a competitor launches a new campaign, tests new messaging, or pulls ads from a region — all from publicly available transparency data. ### How can I use Google Ads Transparency data for brand protection? If competitors or affiliates are running Google Ads using your brand name, trademark, or domain, the Google Ads Transparency Center records those ads publicly. This scraper surfaces them systematically. Run the scraper with your brand name as a `searchTerms` entry and your domain in `domains`. Compare the `advertiserName` and `advertiserId` in results against your known authorized partners. Any advertiser not on your approved list that shows ads for your brand terms is a potential trademark violation or unauthorized affiliate. Set up a weekly scheduled run and configure a Slack or email notification (via Zapier or Make) for any new advertisers that appear in the results. This gives you an automated brand protection monitor without paying for specialized brand safety tools that often charge hundreds of dollars per month. ### What is the difference between Google Ads Transparency Center and Google Ads Manager? The **Google Ads Transparency Center** is a public-facing tool that shows ads from all advertisers running on Google's network. Anyone can search it without a Google account. It was created for regulatory compliance and public transparency. This is the data source this scraper uses. **Google Ads Manager** (formerly Google Ads dashboard) is a private tool for advertisers to manage their own campaigns. It shows your own performance data — impressions, clicks, conversion rates, costs — which is only accessible to the account owner. Key distinction: the Transparency Center shows you what your competitors' ads look like, but not how they perform. It shows creative content, date ranges, and formats — not click-through rates or spend. For competitor performance data, you would need third-party ad intelligence platforms that estimate metrics from panel data. ### How do I research ad creative strategies across an entire industry? Use the scraper to build a comprehensive ad creative library for your competitive landscape: 1. Create a list of 10–20 advertisers in your industry (use competitor names and domains). 2. Run the scraper with `maxAds: 500` per advertiser to capture a broad creative sample. 3. In the output, separate results by `adFormat` — Text, Image, and Video ads serve different purposes and should be analyzed separately. 4. Download available creatives from `mediaUrls` (or the backward-compatible `imageUrl`) to build a visual swipe file. 5. Analyze `headline`, `adText`, `body`, and `callToAction` directly where Google exposes them; retain `previewUrl` for formats with limited structured detail. 6. Sort by `firstShown` and `lastShown` to identify which creatives have run longest — longevity often signals strong performance. Filter by `region` to understand how competitors localize their messaging. Running the same advertiser with `region: "US"` vs. `region: "DE"` reveals whether they use different creative strategies in different markets, which can inform your own localization decisions. ### Can I track Google Ads activity for advertisers in a specific country? Yes. Use the `region` parameter with any ISO country code to filter ads shown in that specific market. For example, `region: "GB"` returns only ads shown to UK audiences, `region: "JP"` returns Japan-specific ads. This is particularly useful for: - **Market entry research** — before entering a new country, see which local and global competitors are actively advertising there and what messaging they use. - **Regulatory compliance research** — different regions may have different ad disclosure requirements. Check what disclosures appear in ads from your industry in each target market. - **Competitive spend signals** — an advertiser who recently expanded ad activity in a new country (visible through `firstShown` dates) may be signaling a market entry or expansion. Leave the `region` field empty to get ads from all regions, which gives you a global view of an advertiser's creative portfolio. ### 🔗 Related scrapers from Automation Lab - [Facebook Ads Library Scraper](https://apify.com/automation-lab/facebook-ads-library) — Scrape ads from Meta's Ad Library across Facebook, Instagram, and Messenger. - [LinkedIn Ad Library Scraper](https://apify.com/automation-lab/linkedin-ad-library-scraper) — Extract LinkedIn ad creatives, headlines, CTAs, funding entities, and media URLs for B2B ad monitoring. - [Google Trends Scraper](https://apify.com/automation-lab/google-trends-scraper) — Extract trending search data and interest over time from Google Trends. - [Google News Scraper](https://apify.com/automation-lab/google-news-scraper) — Scrape news articles and headlines from Google News. - [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) — Find local business leads with contact info from Google Maps. - [YouTube Scraper](https://apify.com/automation-lab/youtube-scraper) — Extract video metadata, channel info, and comments from YouTube. ### Use with AI agents via x402 (no Apify account) Agent workflows can run this actor through Apify MCP without an Apify account when the MCP client uses a funded x402 wallet. Use the actor-specific MCP endpoint: `https://mcp.apify.com?tools=automation-lab/google-ads-scraper&payment=x402` This keeps existing Apify MCP/API usage unchanged; x402 only changes payment/authentication for clients that support it. Learn more in Apify's [x402 integration docs](https://docs.apify.com/platform/integrations/x402). ### Server API: get Google ads over HTTP Google Ads Scraper is also a Server Actor. Besides normal runs, it answers short HTTP requests directly, without starting a run for each lookup. Copy the server URL from the Actor's **Server** tab (do not build it from the Actor name) and authenticate with your Apify token. Use normal Actor runs for many advertisers, domains or terms, more than 100 ads per advertiser, more than 3 advertisers per term, or filters that must scan past 200 ads. ```bash curl -sS "$SERVER_URL/ads?domain=nike.com®ion=US&maxAds=10" -H "Authorization: Bearer $APIFY_TOKEN" curl -sS "$SERVER_URL/ads?advertiserId=AR16735076323512287233®ion=GB&maxAds=20&includeRegionStats=true" -H "Authorization: Bearer $APIFY_TOKEN" curl -sS "$SERVER_URL/search?term=Nike&maxAdvertisers=2&maxAds=10&adFormats=Video" -H "Authorization: Bearer $APIFY_TOKEN" ``` | Method and path | Input | Output and charge | | --- | --- | --- | | `GET /` | None | `ready: true`, the routes and limits; no scraping or charge | | `GET /ads` | Exactly one of query `advertiserId` (such as `AR16735076323512287233`), `domain` (such as `nike.com`) or `url` (an `adstransparency.google.com` advertiser or `?domain=` page; a region or platform in the link overrides the parameters); optional `maxAds` 1–100 (default 20), `region`, `platform`, `adFormats`, `shownAfter`, `shownBefore`, `includeRegionStats` | `{ok,count,results}` with the ads, the same records as a normal run's dataset items; one Ad scraped event per returned ad; no start fee | | `GET /search` | Query `term`: an advertiser name (1–200 characters); optional `maxAdvertisers` 1–3 (default 1; largest matching advertisers first, as normal runs pick them), `maxAds` per advertiser 1–50 (default 20), and the same filters | `{ok,count,results}` with the ads of each advertiser, the same records as a normal run's dataset items; a creative found under two advertisers is returned once; one Ad scraped event per returned ad; no start fee | Filters, as in the normal run input: `region` is a two-letter code such as `US` or a country name (default all regions); `platform` is `SEARCH`, `YOUTUBE`, `SHOPPING`, `MAPS` or `PLAY` (default all); `adFormats` is a comma-separated list of `Text`, `Image`, `Video`; `shownAfter` and `shownBefore` are `YYYY-MM-DD` dates; `includeRegionStats=true` adds `shownCountries`, `regionStats` and `impressionsMin`/`impressionsMax` with one extra Google lookup per ad, at the same price (ads the request had no time to look up have `regionStatsStatus` `"skipped"`). Each advertiser or domain reads at most 5 pages (200 ads) of Google's list, so strict format or date filters can return fewer ads than `maxAds`. A request with no matching ads, or a term with no matching advertiser, returns an error and is free. Each request has a 60-second deadline and a 2 MiB response cap, and one server works on at most four requests at once. Nothing is cached. Errors use `{ "ok": false, "error": { "code": "...", "message": "...", "retryable": false } }`: 400 `INVALID_TARGET`, `INVALID_TERM`, `INVALID_REGION`, `INVALID_PLATFORM`, `INVALID_FILTER`, `INVALID_LIMIT` or `INVALID_INPUT`; 402 spending limit; 404 `NO_RESULTS`, `ADVERTISER_NOT_FOUND` or unknown route; 405 wrong method; 413 `RESPONSE_TOO_LARGE`; 502 `BLOCKED`, `UPSTREAM_ERROR` or charging failure; 503 server busy or stopping; 504 `TIMEOUT`. Failed requests are free. Retry only when `retryable` is true. The Server tab shows the full OpenAPI description. # Changelog This Actor's version history is a separate document: https://apify.com/automation-lab/google-ads-scraper/changelog.md # Actor input Schema ## `searchTerms` (type: `array`): Search for advertisers by name (e.g., Nike, Apple, Coca-Cola). Picks the largest advertisers whose name contains the term, then scrapes their ads. Provide at least one search term, domain, advertiser ID, or start URL. ## `domains` (type: `array`): Search ads by website domain (e.g., nike.com, apple.com). www. and full links are accepted. Provide at least one search term, domain, advertiser ID, or start URL. ## `advertiserIds` (type: `array`): Direct advertiser IDs from Google Ads Transparency Center (e.g., AR16735076323512287233). Provide at least one search term, domain, advertiser ID, or start URL. ## `startUrls` (type: `array`): Paste advertiser or domain pages from adstransparency.google.com, for example https://adstransparency.google.com/advertiser/AR16735076323512287233?region=US\&platform=YOUTUBE. A region or platform in the link overrides the filters below. Links to a single creative are not supported and are skipped. ## `region` (type: `string`): Only return ads shown in this country. Use a two-letter ISO code such as US, GB, DE, SG, AE or BR, or a country name such as Australia. All countries are supported. Leave empty for all regions. ## `platform` (type: `string`): Only return ads shown on this Google platform, as on the Transparency Center filter. Leave empty for all platforms. ## `adFormats` (type: `array`): Return only selected creative formats. Leave empty to include Text, Image, and Video ads. ## `shownAfter` (type: `string`): Optional inclusive lower date bound. Use YYYY-MM-DD, for example 2026-01-01 (January 1, 2026), not 01-01-2026. Return creatives whose shown interval overlaps this date or a later date. Leave empty for no lower bound. ## `shownBefore` (type: `string`): Optional inclusive upper date bound. Use YYYY-MM-DD, for example 2026-01-31 (January 31, 2026), not 31-01-2026. Return creatives whose shown interval overlaps this date or an earlier date. Leave empty for no upper bound. When both bounds are set, this date must be on or after the lower bound. ## `maxAds` (type: `integer`): Maximum number of ads to scrape per advertiser or domain. ## `maxAdvertisersPerTerm` (type: `integer`): How many advertisers to scrape for each search term, largest first. Each one can return up to Max ads per advertiser, so a popular term can return many ads. ## `includeRegionStats` (type: `boolean`): Adds shownCountries (every country where the ad ran), regionStats (per-country first/last shown dates and impressions range) and total impressionsMin/impressionsMax. Google publishes impressions mainly for EU/UK countries. Makes one extra request per ad, so runs take longer (about 1 minute per 100–200 ads); with the default 5-minute timeout, set a longer timeout for more than ~400 ads. Ads the run had no time to look up are still returned, with regionStatsStatus "skipped". Same price per ad. ## Actor input object example ```json { "domains": [ "nike.com" ], "region": "", "platform": "", "adFormats": [], "shownAfter": "", "shownBefore": "", "maxAds": 20, "maxAdvertisersPerTerm": 10, "includeRegionStats": false } ``` # Actor output Schema ## `overview` (type: `string`): Google ad creatives with advertiser details, available headlines and copy, media, formats, shown dates, preview links, and regions. # 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" ], "maxAds": 20 }; // Run the Actor and wait for it to finish const run = await client.actor("automation-lab/google-ads-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"], "maxAds": 20, } # Run the Actor and wait for it to finish run = client.actor("automation-lab/google-ads-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" ], "maxAds": 20 }' | apify call automation-lab/google-ads-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/google-ads-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/0TXh2sQ2VQFw7cvBW/builds/m0kGNWOO6Kt8vBzaF/openapi.json