# Google Ads Library Scraper — Google Ads Transparency Center (`anuarbakty/google-ads-library-scraper`) Actor

Scrape the Google Ads Transparency Center (Google Ads library) by brand, website or advertiser ID: ad text with OCR for text ads kept as pictures, variations, countries, EU reach and targeting, political spend. Check which websites run Google Ads; get only new ads. No login.

- **URL**: https://apify.com/anuarbakty/google-ads-library-scraper.md
- **Developed by:** [Anuar Bakty](https://apify.com/anuarbakty) (community)
- **Categories:** Lead generation, Marketing, Agents
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.96 / 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.
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 Library Scraper** reads the **Google Ads Transparency Center** (the Google Ads library) without a login and gives every ad as a clean row: **the words of the ad**, every A/B variation, every country it ran in with its dates, EU reach and targeting, political spend, the YouTube video of video ads. Search by brand name, website, advertiser ID or a pasted Transparency Center link, check which websites run Google Ads, and get only the new ads of your competitors on a schedule.

Google keeps many Search text ads only as a picture. The Actor reads the words in it with OCR, inside the run, with no AI and no outside service, and splits them into headline, description and display URL. In a run of 300 ZocDoc ads it read the headline of 279 of the 296 text ads; 16 of the other 17 were pictures of Google's own error page, with no ad in them.

![Google Ads Library Scraper results table: headline, description and display URL read from ZocDoc text ads with OCR, first shown date, days shown and number of variations](https://api.apify.com/v2/key-value-stores/zAkhArW4nhu8ZXmvq/records/readme-results.png)

### What does Google Ads Library Scraper do?

- **Finds the ads of any advertiser** by brand name ("Zocdoc"), website ("zocdoc.com"), advertiser ID (AR…), or a Transparency Center link with its filters. Mix them in one run.
- **Gives the words of each ad**: headline, description, display and landing address, business name, sitelinks, button, phone, category. From Google's preview data when it has them, from the ad picture with OCR when it does not.
- **Reads every A/B variation** of an ad, each with its own words and picture.
- **Lists every country** the ad ran in, with the first and last day shown there.
- **Adds EU reach and targeting**: Google's impression ranges per country and per platform, and the demographics, locations and topics the advertiser targeted.
- **Adds political ad data**: impression and spend ranges, and the places targeted.
- **Gives the YouTube video ID and link** of video ads.
- **Checks websites in bulk**: does this website run Google Ads, who the advertiser is, Google's count of its ads, its latest ad. A website without ads gives a free row.
- **Monitors competitors**: with **Only new ads** on, a scheduled run delivers only the ads that appeared since the last run, with a message to Slack, Discord, Telegram or any webhook.

### Why use this Google Ads Transparency Center scraper?

| What goes wrong elsewhere | What happens here |
|---|---|
| Text ads come back as a picture link, "OCR on, still no text" | The words are read and split into headline, description and display URL. Every row says where its text came from and, when there is none, why |
| "Returns 0 and no error" | Every input that gives nothing produces a free row with the reason: no ads, advertiser not found, Google refused |
| Fewer ads than Google shows | Each advertiser or website gets a free summary row: how many ads were delivered and why the list ended, and for an advertiser Google's count of its ads. One run read 1,000 ads of one website |
| "Limit 5, got 95 rows" | The Actor stops exactly at your limit and at the maximum cost you set for the run |
| An automation built for another scraper has to be rebuilt | Inputs of other Google Ads Transparency scrapers run unchanged: 121 of their example and public task inputs were tested |
| Every request answered with 429 | Requests change address as they go and move to residential proxies when Google keeps refusing datacenter ones |

### What Google Ads data can you extract?

| Data | Fields |
|---|---|
| The ad | Creative ID, ad link, format (text, image, video), first and last shown, days shown, active now, preview picture |
| Words | Headline, description, display URL, landing URL, business name, button, phone, sitelinks, local category, text source and status |
| Variations | Every A/B variation with its picture and its own words |
| Countries | Every country with its first and last day; for the EU, impression ranges per country and per Google platform |
| Targeting (EU) | Demographics, locations and contextual topics, included and excluded |
| Political ads | Impression range, spend range and currency, targeted places |
| Video ads | YouTube video ID and link |
| Advertiser | Name, ID, country, verified badge, Google's count of its ads |
| Landing page (optional) | Final address, HTTP status, title, description, first heading, main button |

The full list is in [Output](#output).

### What can you use it for?

- **Competitor ad research**: every Google ad a competitor runs, with its copy, the countries it targets and how long each ad has been running.
- **A swipe file of Search ads**: headlines and descriptions of a whole niche, ready for a spreadsheet.
- **Lead generation for agencies**: which of 1,000 websites run Google Ads, who the advertiser is and how many ads Google counts.
- **Monitoring**: the new ads of each competitor every morning, in Slack or Telegram.
- **EU transparency research**: reach and targeting of ads shown in the European Union.
- **Political ad research**: spend and impression ranges of election ads.
- **AI agents and automation**: clean rows for n8n, Make, Zapier, Clay or an MCP agent.

### How to scrape the Google Ads Transparency Center

1. Type brand names, websites, advertiser IDs or Transparency Center links into **Brands, websites, advertiser IDs or links**, one per line.
2. Set the **Region**, and if you need them the Google platforms (Search, YouTube, Shopping, Maps, Play), format and dates.
3. Click **Start**. 50 ads with their words take about two minutes.
4. Open the **Output** tab and export the rows to Excel, CSV or JSON, or read them through the API.

| You give | You get |
|---|---|
| `zocdoc.com`, region `US` | Every ad that leads to zocdoc.com, from any advertiser, with its words and countries |
| `Zocdoc` | The ads of the advertiser accounts whose names start with it; for one exact company give its website or advertiser ID |
| `AR14488231321538658305` | The ads of that advertiser |
| A Transparency Center link | The ads the link shows, with the region, platform, format and dates set in it |
| 500 websites, **What to return** = Advertiser check | One row per website: does it run Google Ads, the advertiser, its ad count and latest ad |

### How much does it cost to scrape Google ads?

You pay per result, not for time or memory. Ad text, variations, countries, EU reach and targeting are included in the price of the ad.

| What | Price on the Free plan |
|---|---|
| An ad with all its data | **$1.50 per 1,000 ads** |
| A row of the advertiser check | $1.50 per 1,000 websites or advertisers |
| A landing page (optional) | $0.50 per 1,000 pages |
| Run start, Apify's standard start fee | $0.0001 with the default 2 GB of memory |
| Summary rows, rows that explain an empty input, websites without ads, an ad that two inputs share | free |

Paid Apify plans pay less per ad: $1.20 on Bronze, $1.08 on Silver, $0.96 on Gold per 1,000.

| Example | Cost on the Free plan |
|---|---|
| 1,000 ads of one competitor | $1.50 |
| The last 100 ads of 20 advertisers | $3.00 |
| Which of 1,000 websites run Google Ads | $1.50 |
| A daily check of 10 competitors that finds 30 new ads | $0.05 |

Apify's free plan includes $5 of credit every month, enough for about 3,300 ads.

### Input

Brands, websites, advertiser IDs and links can go into one field, **Brands, websites, advertiser IDs or links**; the Actor tells them apart. A list can also be pasted, or loaded from a .txt or .csv file, a Google Sheet or a Google Drive file.

```json
{
    "queries": ["zocdoc.com", "Example Dental Group", "AR14488231321538658305"],
    "region": "US",
    "adPlatforms": ["SEARCH"],
    "startDate": "30 days",
    "maxAdsPerSearch": 100
}
```

Filters: **Region** (a code, a name, several, or anywhere), **Google platforms**, **Ad format**, **Shown on or after** and **Shown on or before** (a date or a number of days back), **Political ads**. A filter written in a Transparency Center link wins for that link.

Limits: **Max ads per advertiser or website**, **Max paid rows in the run**, and the maximum cost of the run that you set in Apify.

#### Coming from another Google Ads Transparency scraper?

Paste your input as it is. These field names are read too: `domains`, `advertiserIds`, `startUrls`, `urls`, `searchQuery`, `resultType`, `searchMode`, `regionCode`, `country`, `platforms`, `adFormat`, `format`, `startDate`, `endDate`, `dateFrom`, `dateTo`, `resultsLimit`, `maxResults`, `maxAds`, `maxItems`, `includeDetails`, `includeAdText`, `ocrImageOnlyText`, `onlyNew`, `onlyNewAds`, `webhookUrl`, `slackWebhookUrl` and more. A field that does not apply here is named in the log with the reason.

### Output

Every row has a `type`: `ad` (paid), `advertiser` (Advertiser check, paid), `summary` (free, one per advertiser or website) or `notice` (free, an input that gave nothing, with a `code`: `NO_ADS`, `NOT_FOUND`, `FETCH_FAILED`, `INVALID_INPUT`).

One row per ad:

```json
{
    "type": "ad",
    "source": "example-clinic.com",
    "advertiserId": "AR00000000000000000001",
    "advertiserName": "Example Clinic, Inc",
    "creativeId": "CR00000000000000000001",
    "adUrl": "https://adstransparency.google.com/advertiser/AR00000000000000000001/creative/CR00000000000000000001?region=US",
    "format": "TEXT",
    "headline": "Same-Day Appointments - Book a Dentist Near You",
    "description": "Book a time that fits your schedule. Choose from highly-reviewed dentists who accept your insurance.",
    "displayUrl": "book.example-clinic.com/dentist",
    "landingUrl": "https://book.example-clinic.com/dentist",
    "businessName": "Example Clinic",
    "textSource": "ocr",
    "textStatus": "read",
    "firstShown": "2026-04-22T18:45:53.926Z",
    "lastShown": "2026-11-06T18:35:54.951Z",
    "daysShown": 199,
    "isActive": true,
    "regions": ["US"],
    "variationCount": 3,
    "variations": [
        { "headline": "Same-Day Appointments - Book a Dentist Near You", "textSource": "ocr", "textStatus": "read" },
        { "headline": "Dentists Who Take Your Insurance - Book Online", "textSource": "ocr", "textStatus": "read" },
        { "headline": "New Patient Dental Exams - Book Today", "textSource": "ocr", "textStatus": "read" }
    ],
    "youtubeVideoId": null
}
```

`textSource` says where the words come from: `preview` or `script` (Google's preview data) or `ocr` (read from the picture). `textStatus` says what happened: `read`, `low_confidence` (OCR words kept, `ocrConfidence` under 50 of 100), `no_text_found`, `google_error_picture` (Google archived a picture of its error page instead of the ad) or `ocr_off`.

Video ads carry `youtubeVideoId` and `videoUrl`. One video often runs as several ads, so the same video can appear in several rows.

EU ads also carry `regionStats` (every country with its dates and impression range), `euImpressionsMin` / `euImpressionsMax`, `euImpressionsByPlatform` and `targeting`. Political ads carry `politicalImpressionsMin` / `Max`, `politicalSpendMin` / `Max`, `politicalSpendCurrency` and `politicalGeoTargetIds`.

#### Summary rows

Each advertiser or website also gets a free `summary` row: how many ads were delivered and how many are active now, for an advertiser Google's count of its ads, the number of text, image and video ads, the median and longest days shown, the 5 longest-running ads, and why the list stopped.

#### Advertiser check rows

With **What to return** set to **Advertiser check**, each website or advertiser gives one row: `runsGoogleAds`, the advertiser (for a website, the advertiser of its latest ad) with its name, ID, country and verified badge, Google's ad count range for that advertiser's whole account, and the latest ad with its dates and format.

### Monitor competitors' new Google ads on a schedule

1. Put your competitors into the input and turn on **Only new ads**.
2. Give the watch list a **Memory name**, one per list.
3. Paste a Slack or Discord webhook, a Telegram bot link or any webhook into **Send a message when the run ends**.
4. Save the input as a task and schedule it daily or weekly.

The first run delivers what it finds and remembers it. Every later run delivers only the ads that were not delivered before; ads it skips are free.

### Is it legal to scrape the Google Ads Transparency Center?

The Transparency Center is a public tool: Google publishes it so that anyone can see who advertises on its platforms and what they show, and the Actor reads only what any visitor sees without logging in. It does not log in and reads nothing behind a login.

Rows can still contain personal data, for example the name of a person who advertises under their own name or who pays for a political ad. Collect and use it only for a purpose you can justify under the rules that apply to you, such as the GDPR. If you are not sure, ask a lawyer.

### Integrations and API

Results export to JSON, CSV, Excel and HTML. Runs can be scheduled, called through the Apify API and connected to Make, Zapier, n8n, Clay, Google Sheets or your own webhook.

```bash
curl -X POST "https://api.apify.com/v2/acts/anuarbakty~google-ads-library-scraper/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["zocdoc.com"], "region": "US", "maxAdsPerSearch": 50}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_TOKEN>")
run = client.actor("anuarbakty/google-ads-library-scraper").call(run_input={"queries": ["zocdoc.com"], "region": "US", "maxAdsPerSearch": 50})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["type"], row.get("headline"))
```

Each run also writes a `SUMMARY` record to its key-value store: rows per target, requests, refusals and the reason the run stopped.

#### Use it from AI agents (MCP)

The Actor works as a tool through the [Apify MCP server](https://mcp.apify.com): `https://mcp.apify.com/?tools=anuarbakty/google-ads-library-scraper`. A typical request:

> Show me the Google Search ads Zocdoc runs in the US right now.

The agent calls the Actor with `{"queries": ["zocdoc.com"], "region": "US", "adPlatforms": ["SEARCH"], "fastMode": true}`. **Fast mode** answers within about 30 seconds with up to 10 ads and their words; it took 28 seconds in our test through MCP. A mistyped input comes back as a free row that says what to fix.

Apify's video shows how to set up the MCP server:

https://www.youtube.com/watch?v=1i-dKo-0puk

### More from this developer

- **[Facebook Ads Library Scraper](https://apify.com/anuarbakty/facebook-ads-library-scraper)**: Facebook and Instagram ads from the Meta Ad Library by keyword, brand, page or Instagram account, with copy, creatives, EU reach and advertiser contacts, no login.
- **[App Store Reviews & Google Play Reviews Scraper](https://apify.com/anuarbakty/app-store-play-scraper)**: reviews, app details, ratings histogram, search, top charts and keyword rankings from both stores in one run.
- **[YouTube Transcript Scraper](https://apify.com/anuarbakty/youtube-transcript-scraper)**: transcripts and subtitles of YouTube videos, Shorts, channels, playlists and search, as text, timestamps, SRT or VTT.
- **[Instagram Transcript Generator](https://apify.com/anuarbakty/instagram-reels-transcript-generator)**: Instagram reels to text with timestamps, SRT and VTT subtitles and the opening hook.
- **[Threads Scraper](https://apify.com/anuarbakty/threads-scraper)**: posts, all replies and profiles from Threads without login, keyword search and only-new monitoring.
- **[2GIS Places Scraper](https://apify.com/anuarbakty/2gis-places-scraper)**: businesses from 2GIS with phones, WhatsApp, Telegram, emails and websites.
- **[2GIS Reviews Scraper](https://apify.com/anuarbakty/2gis-reviews-scraper)**: 2GIS reviews with star, topic and date filters and only-new monitoring.
- **[Pinterest Search Scraper](https://apify.com/anuarbakty/pinterest-search-scraper)**: Pinterest pins, boards and profiles without login, with real pin links, saves, repins and comments, plus Pinterest Trends and search suggestions.

### FAQ

**Do I need a Google account, cookies or an API key?**
No. The Actor reads what the Transparency Center shows any visitor.

**Is there a Google Ads Transparency Center API?**
Google has no official API for it. It publishes a BigQuery public dataset of ad statistics for the European Economic Area and Turkey, updated with a delay, which you query with SQL in your own Google Cloud project. The Actor reads every region from the Transparency Center itself and gives the words of each ad, in one run, through the Apify API or MCP.

**How do I see a competitor's Google ads?**
Type the competitor's website, for example `zocdoc.com`: you get every ad that leads to it, from any advertiser account. A brand name finds the advertiser accounts whose names start with it, the biggest first.

**Can I get the text of Google Search ads?**
Yes. The headline, description and display URL of each text ad come from Google's preview data or, when Google keeps the ad only as a picture, from OCR of the picture. **Read every variation** reads the words of all A/B variations.

**How many ads can I get per advertiser?**
As many as Google lists. One test run read 1,000 ads of one website; set **Max ads per advertiser or website** to the number you need.

**How far back does the Google Ads library go?**
Google shows ads from several years back with their first and last shown dates; our tests found ads first shown in 2022. The date filter covers the last 12 months, the way Google's own filter does.

**Which websites run Google Ads?**
Put the websites into **Websites (exact)** and set **What to return** to **Advertiser check**. Each website gives one row with `runsGoogleAds`, the advertiser and its latest ad; a website without ads gives a free row.

**Can I download the images and videos?**
Every row carries the link of the ad picture and of each variation, and video ads carry the YouTube video ID and link.

**How do I export Google Ads Transparency data to Excel or Google Sheets?**
When the run ends, open the **Output** tab and export to Excel or CSV, or connect the Actor to Google Sheets to get the rows after every run.

**A run finished as "succeeded" but there are no ads.**
There is a free row that says why: no ads for these filters, an advertiser that was not found, or Google refusing the requests. Inputs that Google refuses are read once more at the end of the run, after a pause; if Google still refuses, the run's message says so, and running again a few minutes later works. The run succeeds so that an automation that sends one advertiser per run keeps going. Turn on **Fail the run when nothing is delivered** if you want a failed status.

**Something does not work or a field is missing.**
Open an issue on the Issues tab with the run ID. Every input that gave less than asked already explains why in its summary or notice row.

# Actor input Schema

## `queries` (type: `array`):

One per line. A website ("zocdoc.com") gives every ad that points to it, from any advertiser. A brand name ("Zocdoc") goes through the Transparency Center search to the advertiser accounts whose names start with it. An advertiser ID (AR…) gives that advertiser's ads. A Transparency Center link (advertiser, ad or website search) keeps the filters in it. For one exact company, give its website or advertiser ID.

## `domains` (type: `array`):

Same as a website in the first field, but never read as a brand name: every ad that points to the site, from any advertiser. In Advertiser check: does the website run Google Ads, and the advertiser of its latest ad.

## `advertiserIds` (type: `array`):

Advertiser IDs that start with AR, from the advertiser page address on the Transparency Center.

## `startUrls` (type: `array`):

Advertiser pages, ad pages or website searches copied from adstransparency.google.com. The region, platform, format and dates in the link are used for that link.

## `urlsFromFile` (type: `string`):

Paste lines (one target per line), or one link to a .txt or .csv file, Google Sheet or Google Drive file with them. Share the file so that anyone with the link can view it.

## `resultType` (type: `string`):

"ads" (default): every ad with its details. "advertisers" (Advertiser check): one row per website or advertiser with runsGoogleAds true or false, the advertiser (for a website, the advertiser of its latest ad), the ad count of that advertiser's whole account, country, verified badge and the latest ad. A website without ads gives a free row.

## `region` (type: `string`):

Where the ads were shown: a two-letter code ("US", "DE"), an English name ("Germany"), several separated by commas ("US, CA"), or "anywhere" for all regions.

## `adPlatforms` (type: `array`):

Only ads shown on these Google platforms. Empty = all. Google filters by platform only for ads shown since 2023-09-04.

## `creativeFormat` (type: `string`):

Only ads of this format.

## `startDate` (type: `string`):

Ads shown at any time on or after this date, including ads that started earlier. A date like 2026-10-01, or a number of days back: "30 days" = shown in the last 30 days. Google keeps the last 12 months of dates for this filter.

## `endDate` (type: `string`):

A date like 2026-11-01, or a number of days back like "7 days". Empty = today.

## `politicalAds` (type: `boolean`):

Read Google's political ads view: impressions and spend ranges of each ad, and the places it targeted. Needs a region; the United States includes its territories.

## `maxAdsPerSearch` (type: `integer`):

Ads to deliver for each advertiser, website or link. A brand name reads up to "Max advertisers per brand name" accounts, each with this limit; for a hard total use "Max paid rows in the run".

## `maxItems` (type: `integer`):

Stops the run after this many ads or advertiser rows. Set it here in the input: the run option of the same name does not limit this Actor. Empty = no limit besides the run's maximum cost.

## `maxAdvertisersPerQuery` (type: `integer`):

A brand name can match several advertiser accounts (one per country or company). This many of the first matches are read.

## `includeDetails` (type: `boolean`):

One more request per ad gives every variation, every country with its dates, and for EU ads the impression ranges per platform and the targeting. Included in the ad price. Off = faster, with the list fields only.

## `includeAdText` (type: `boolean`):

Headline, description, display and landing address, sitelinks, button, video ID: read from Google's preview. Included in the ad price.

## `ocr` (type: `boolean`):

Google keeps many text ads only as a picture. With this on, their words are read with Tesseract inside the run, no AI and no outside service. Off = faster, those ads keep the picture link only.

## `ocrAllVariations` (type: `boolean`):

Read the words of every A/B variation, not only the first. Slower for text ads kept as pictures.

## `landingPages` (type: `boolean`):

Open the page each ad leads to: final address, HTTP status, title, description, first heading, main button. Charged per page as "landing-page".

## `onlyNewAds` (type: `boolean`):

Deliver only ads that earlier runs with the same memory did not deliver. Schedule the run daily or weekly to get new competitor ads only. The first run delivers what it finds and remembers it.

## `monitorStoreName` (type: `string`):

Name of the memory of "only new ads" in your account. Use one name per watch list, so that lists do not mix.

## `webhookUrl` (type: `string`):

A Slack or Discord webhook, a Telegram bot link (https://api.telegram.org/bot<token>/sendMessage?chat_id=<chat>) or any webhook (Make, n8n, Zapier): it gets the count of ads and the dataset link.

## `notifyWhen` (type: `string`):

"When there are ads" skips runs that found nothing.

## `skipDuplicateAds` (type: `boolean`):

When two inputs lead to the same ad (a website and its brand name), the ad is delivered and charged once. The summary of the second input counts it.

## `tags` (type: `array`):

Added to every row, to tell runs and lists apart in one table.

## `includeErrorRows` (type: `boolean`):

A free row of type "notice" for each input that gave nothing, with a code (NO_ADS, NOT_FOUND, FETCH_FAILED, INVALID_INPUT) and the reason.

## `customMapFunction` (type: `string`):

A function that takes a row and returns a new one, e.g. (row) => ({ ...row, brand: row.advertiserName }). Return nothing to drop the row. The columns type, source, tags and scrapedAt stay.

## `fastMode` (type: `boolean`):

For agents whose tool call waits 30 to 45 seconds: at most 10 ads in the whole run, the first variation of each, no landing pages; ad text and OCR stay on. Overrides larger limits.

## `maxConcurrency` (type: `integer`):

How many ads are read at once.

## `proxyConfiguration` (type: `object`):

Google limits each address after a few dozen requests, so the run changes addresses as it goes. Apify Proxy is used by default.

## `residentialFallback` (type: `boolean`):

When Google keeps refusing datacenter addresses, move to residential ones.

## `failIfAllInputsFail` (type: `boolean`):

Off: a run that delivers nothing still succeeds and explains why in free rows, so schedules and integrations keep going.

## `strictInput` (type: `boolean`):

On: an unknown field name stops the run before anything is read or charged.

## Actor input object example

```json
{
  "queries": [
    "zocdoc.com"
  ],
  "resultType": "ads",
  "region": "anywhere",
  "adPlatforms": [],
  "creativeFormat": "ALL",
  "politicalAds": false,
  "maxAdsPerSearch": 20,
  "maxAdvertisersPerQuery": 5,
  "includeDetails": true,
  "includeAdText": true,
  "ocr": true,
  "ocrAllVariations": true,
  "landingPages": false,
  "onlyNewAds": false,
  "monitorStoreName": "google-ads-library-monitor",
  "notifyWhen": "ads",
  "skipDuplicateAds": true,
  "includeErrorRows": true,
  "fastMode": false,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "residentialFallback": true,
  "failIfAllInputsFail": false,
  "strictInput": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "zocdoc.com"
    ],
    "maxAdsPerSearch": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("anuarbakty/google-ads-library-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": ["zocdoc.com"],
    "maxAdsPerSearch": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("anuarbakty/google-ads-library-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 '{
  "queries": [
    "zocdoc.com"
  ],
  "maxAdsPerSearch": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call anuarbakty/google-ads-library-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,anuarbakty/google-ads-library-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 <APIFY_API_TOKEN>` 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/m74t6QByt0kVZYBue/builds/L0jQr5c3v2MI0SEhL/openapi.json