# Google Ads Transparency & Ad Library Scraper API – No Login (`k-data-lab/google-ad-library-scraper`) Actor

Get Google Ads Transparency Center ads for any domain, brand or advertiser ID, no login: format, dates, days shown, images, plus ad text, landing page, variations and EU impressions. Only-new-ads monitor for daily competitor alerts. Search, YouTube, Shopping, Maps, Play. 100 free/month.

- **URL**: https://apify.com/k-data-lab/google-ad-library-scraper.md
- **Developed by:** [K-Data Lab](https://apify.com/k-data-lab) (community)
- **Categories:** SEO tools, Lead generation, Agents
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 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 Transparency & Ad Library Scraper API – No Login

**Type a competitor's domain or brand, click Start, get every Google ad they run as a table.** This actor reads the
public **Google Ads Transparency Center** (Google's ad library): format, first and last shown dates, days shown, the
ad image or preview and, with one add-on, the **ad text, landing page, video, every variation and each country it ran
in** with EU impression ranges. Search, YouTube, Shopping, Maps and Play ads.

- ✅ **No login, no cookies, no Google account**: paste `nike.com` or `HubSpot` and run
- 💰 **First 100 results every month free**, then from **$0.60 per 1,000 ads**; ad text + landing page + countries for $1 per 1,000 more
- 🔔 **Only-new-ads monitor**: schedule it daily and get just the ads a competitor launched since the last run; ads you already have are skipped and never charged
- 🔌 **Use it as an API**: one HTTP call returns JSON, CSV or Excel; works with n8n, Make, Zapier and AI agents (MCP)

Example row (real ad, `adidas.com`, US, full details on):

| advertiserName | format | firstShown | lastShown | daysShown | variationCount | landingUrl |
|---|---|---|---|---|---|---|
| Adidas America, Inc | IMAGE | 2026-10-20 | 2026-10-23 | 4 | 3 | https://www.adidas.com/us/stan_smith |

> Independent tool by K-Data Lab. Not affiliated with, endorsed or sponsored by Google. It reads only the public
> Ads Transparency Center (adstransparency.google.com), no login, and returns only what Google publishes there.

#### 🔍 What does Google Ad Library Scraper do?

- **Ads by domain**: `nike.com` returns every advertiser's ads that point to nike.com (brand, resellers, agencies)
- **Ads by brand name**: `HubSpot` is matched to the verified advertiser with the most ads
- **Ads by advertiser ID or link**: paste `AR…` IDs or Transparency Center links (an advertiser page, a domain search or a single ad)
- **Filters**: country shown in (243 countries), format (text / image / video), Google platform (Search, YouTube, Shopping, Maps, Play), date range
- **Full ad details** (optional): headline, description, display URL, texts, landing page URL, YouTube video ID or MP4, every variation, countries with first/last shown dates, EU impressions by platform, topic
- **Only new ads (monitor mode)**: the actor remembers which ads each input line already returned and gives you only the new ones on the next run
- **Advertisers only** output: find advertiser IDs, verified countries and ad counts for a brand, or every advertiser running ads to a domain

#### 💡 Why choose this actor?

- 💰 **Lower price**: ads from $0.60–0.90 per 1,000 and full details for $1 per 1,000, with 100 free results every month
- 📝 **Ad text and landing page included in one add-on**, not split into several paid extras
- 🌍 **Per-country reach**: each country the ad ran in, with dates and (in the EU) impression ranges by platform
- ⚡ **Fast and light**: plain HTTP, 256 MB, about 40 ads per request; Apify Proxy only when Google slows down
- 🛡️ **Never charged twice**: an ad found by two input lines is returned and charged once; with the monitor on, ads from earlier runs are skipped for free; empty queries cost nothing

#### 📥 Input example

```json
{
  "queries": ["nike.com", "HubSpot", "AR16735076323512287233"],
  "region": "US",
  "format": "ALL",
  "platform": "ALL",
  "dateFrom": "2026-09-01",
  "maxAdsPerQuery": 200,
  "includeDetails": true
}
```

| Field | What it does |
|---|---|
| `queries` | Domains, brand names, advertiser IDs (AR…) or Transparency Center links, one per line |
| `region` | Country the ads were shown in (`anywhere` = all) |
| `format` | `ALL`, `TEXT`, `IMAGE`, `VIDEO` |
| `platform` | `ALL`, `GOOGLE_SEARCH`, `YOUTUBE`, `GOOGLE_SHOPPING`, `GOOGLE_MAPS`, `GOOGLE_PLAY` |
| `dateFrom` / `dateTo` | Only ads shown in this period (YYYY-MM-DD) |
| `maxAdsPerQuery` | Stop after this many ads per line |
| `includeDetails` | Ad text, landing page, video, variations, countries, impressions, topic |
| `onlyNewAds` | Monitor mode: return only ads no earlier run of this line (same filters) returned; `maxAdsPerQuery` = ads checked per line |
| `advertisersPerName` | Max advertisers per brand name (default 1 for ads, 10 for advertisers mode). Whole-word name matches only; the brand's own account first (`Nike` → Nike, Inc.), then most ads |
| `mode` | `ads` or `advertisers` (advertiser lookup only) |

#### 🧪 Ready-made inputs

| Goal | Input |
|---|---|
| Every ad pointing to a website (brand, resellers, affiliates) | `{"queries": ["nike.com"], "maxAdsPerQuery": 500}` |
| A brand's YouTube video ads in the UK | `{"queries": ["Spotify"], "region": "GB", "platform": "YOUTUBE", "format": "VIDEO"}` |
| Ad copy and landing pages of Search ads | `{"queries": ["hubspot.com"], "platform": "GOOGLE_SEARCH", "includeDetails": true}` |
| Daily alert of a rival's new ads (schedule it) | `{"queries": ["shopify.com", "wix.com"], "onlyNewAds": true, "maxAdsPerQuery": 300}` |
| Ads shown since a date | `{"queries": ["shopify.com"], "dateFrom": "2026-10-24"}` |
| Find the exact advertiser IDs for a brand | `{"queries": ["Samsung"], "mode": "advertisers"}` |

#### 📤 Output example

One row per ad (the `Ads` view shows the image, advertiser, dates and links). A real record with full details:

```json
{
  "adId": "CR07054792377080217601",
  "advertiserId": "AR14017378248766259201",
  "advertiserName": "Adidas America, Inc",
  "domain": "adidas.com",
  "format": "IMAGE",
  "firstShown": "2026-10-20T17:44:06Z",
  "lastShown": "2026-10-23T23:43:41Z",
  "daysShown": 4,
  "imageUrl": null,
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integrity-transparency&…",
  "adUrl": "https://adstransparency.google.com/advertiser/AR14017378248766259201/creative/CR07054792377080217601?region=US",
  "query": "adidas.com",
  "region": "US",
  "variationCount": 3,
  "regions": [{"countryCode": "US", "country": "United States", "firstShown": null, "lastShown": "2026-10-23",
               "impressionsMin": null, "impressionsMax": null, "impressionsByPlatform": []}],
  "adText": {
    "texts": ["Explore The Latest Shoes, Clothing & Accessories On", "adidas.com.",
              "The Stan Smith sneaker is a timeless design", "inspired by the tennis legend", "Place Your Order Today"],
    "landingUrls": ["https://www.adidas.com/us/stan_smith"],
    "headline": null, "youtubeVideoId": null, "videoUrl": null
  },
  "landingUrl": "https://www.adidas.com/us/stan_smith"
}
```

For ads shown in the EU, `regions` also carries Google's impression ranges by platform (real `adidas.de` ad):

```json
"regions": [{
  "countryCode": "DE", "country": "Germany", "firstShown": "2023-03-01", "lastShown": "2026-10-23",
  "impressionsMin": 10000000, "impressionsMax": null,
  "impressionsByPlatform": [
    {"platform": "GOOGLE_SEARCH", "impressionsMin": 10000000, "impressionsMax": null},
    {"platform": "GOOGLE_SHOPPING", "impressionsMin": 1500000, "impressionsMax": 1750000},
    {"platform": "YOUTUBE", "impressionsMin": 70000, "impressionsMax": 80000}
  ]
}]
```

Field notes:

- `daysShown`: number of days Google showed the ad (from the Transparency Center)
- `imageUrl`: image ads and older text ads are archived by Google as images; `previewUrl` is Google's preview script for HTML and video ads
- `impressionsMin` / `impressionsMax`: Google publishes impression ranges for ads shown in the EU (and political ads); `impressionsMax: null` means "or more"
- `adText.headline` / `description` / `displayUrl`: for search text ads with a live preview; other ads list their visible `texts`
- `partialDetails: true`: Google has no public detail record for a few live ads (its own ad page shows nothing either). You still get the text and landing page when the ad has a preview; `regions` is only the country you searched, impressions are empty, and the details charge is skipped
- Run summary (key-value store `RUN_SUMMARY`): per input line, the advertisers used, how many ads Google reports for your filters, and a status (`OK`, `NO_ADS`, `NO_NEW_ADS`, `NO_ADVERTISER_FOUND`, `INVALID_QUERY`, `ERROR`)

#### ⚠️ When a line returns nothing

- `NO_ADVERTISER_FOUND`: no verified advertiser name has every word you typed as a whole word (`Nike` matches Nike, Inc. and NIKE SRL, not Nikesh), and the brand's own website shows none either. Use the website domain instead (`brand.com`), or `Advertisers only` mode to see the exact advertiser names.
- `NO_ADS`: the advertiser or domain has no ads for these filters (country, format, platform, dates).
- `NO_NEW_ADS` (monitor mode): every ad checked was already returned by an earlier run. The summary shows `checked` and `alreadySeen`.
- `INVALID_QUERY`: a Transparency Center link without an advertiser, ad or domain in it.

Nothing is charged for a line that returns nothing.

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

| Event | Price |
|---|---|
| Ad scraped | **$0.0009** (Free plan) · $0.0008 (Bronze) · $0.0007 (Silver) · $0.0006 (Gold and up) |
| Ad details (only with *Full ad details* on) | $0.001 per ad |
| Advertiser found (*Advertisers only*) | $0.0005 |
| Actor start | $0.005 per run |

**The first 100 results each calendar month are free**, details included. Examples: 1,000 ads ≈ $0.90; 1,000 ads with full
details ≈ $1.90. Set *Maximum cost per run* in the run options and the actor stops cleanly at that limit.

#### 🚀 How to scrape Google Ads Transparency Center (step by step)

1. Open the actor and click **Try for free**.
2. Paste competitor domains or brand names into **Advertisers, brands or domains**.
3. Pick a country, format, platform or dates if you need them.
4. Turn on **Full ad details** for ad text, landing pages and countries.
5. Click **Start**, then download the results as Excel, CSV or JSON.

#### 📊 Popular use cases

- **Competitor ad research**: which messages, offers and landing pages a rival is testing right now
- **Ad creative swipe files** for agencies and copywriters
- **Market entry checks**: which countries a competitor advertises in, since when, and how much (EU)
- **Brand protection**: find resellers, affiliates and look-alike advertisers bidding on your domain
- **Lead lists for agencies**: which companies are actively advertising (advertiser names and IDs, no personal contact data)
- **Monitoring**: turn on *Only new ads*, schedule a daily run and send the new rows to Slack, Sheets or email through an Apify integration

#### 🔌 Integrations & API

Run it from your code with the Apify API or client libraries:

```python
from apify_client import ApifyClient

client = ApifyClient('<YOUR_APIFY_TOKEN>')
run = client.actor('k-data-lab/google-ad-library-scraper').call(run_input={
    'queries': ['nike.com'], 'region': 'US', 'maxAdsPerQuery': 100, 'includeDetails': True})
for ad in client.dataset(run['defaultDatasetId']).iterate_items():
    print(ad['advertiserName'], ad['format'], ad['lastShown'], ad.get('landingUrl'))
```

```bash
curl -X POST "https://api.apify.com/v2/acts/k-data-lab~google-ad-library-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H 'Content-Type: application/json' -d '{"queries": ["hubspot.com"], "maxAdsPerQuery": 50}'
```

It also connects to Google Sheets, Slack, Zapier, Make, n8n and webhooks through Apify integrations, and works as an
MCP tool for AI agents.

#### 💡 Tips

- A **domain** finds more ads than a brand name: big brands advertise under several legal entities (e.g. Nike, Inc. and Nike Retail BV).
- Leave **Full ad details** off for fast, cheap lists; turn it on for the ads you want to study.
- Use **Advertisers only** first to get exact advertiser IDs, then scrape those IDs.
- Google reports totals as ranges (e.g. 70,000–80,000 ads); the run summary shows them per query.

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

Give Claude, ChatGPT, Cursor, VS Code or n8n a ready-made `google-ad-library-scraper` tool through [Apify's MCP server](https://mcp.apify.com): the agent reads the input schema, runs this actor and gets the dataset back.

- This actor only: `https://mcp.apify.com?tools=actors,docs,k-data-lab/google-ad-library-scraper`
- Google set (Google Play + Google Ads Transparency): `https://mcp.apify.com?tools=actors,docs,k-data-lab/google-play-scraper,k-data-lab/google-ad-library-scraper`

**Claude Code**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=actors,docs,k-data-lab/google-ad-library-scraper"
```

Claude Desktop: Settings → Connectors → Add custom connector, paste the same URL.

**Cursor / VS Code** (`.cursor/mcp.json`; in `.vscode/mcp.json` use `"servers"` and add `"type": "http"`)

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=actors,docs,k-data-lab/google-ad-library-scraper",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

**Try asking**

- "Show me the 30 latest video ads that point to nike.com in the US, with landing pages."
- "Which advertisers are running Google ads for hubspot.com, and how many ads does each have?"
- "Monitor HubSpot's Google ads in Germany and tell me only the new ones since the last run."

#### ❓ FAQ

**Is it legal to scrape the Google Ads Transparency Center?** The Transparency Center is a public library Google
publishes so anyone can see who advertises what. This actor reads only that public data, without login, at a polite
rate. You are responsible for how you use the data; check your local laws and Google's terms for your use case.

**Does it return personal data?** No contact data at all. Advertiser names are the verified names Google itself
publishes for each advertiser; some advertisers are verified individuals, so treat names as you would any public record.

**Why is there no text for some ads?** Google archives many text ads as images; the actor then returns the `imageUrl`.
Ads with a live preview get their text and landing page with *Full ad details*.

**How far back does it go?** As far as the Transparency Center does (several years for many advertisers).

**Can I get only new ads?** Yes. Turn on **Only new ads (monitor mode)** and schedule the actor. Each run returns only
ads that earlier runs of the same input line and filters did not return, each marked `isNew: true`, and skipped ads cost
nothing. The memory is a key-value store named `k-data-lab-google-ads-seen` in your own Apify account; delete it to
start over. For a fixed window instead, set `dateFrom`.

#### 🧰 More from K-Data Lab

- [Amazon ASIN Rating & Review Count Scraper](https://apify.com/k-data-lab/amazon-asin-rating-scraper): star rating, review count, 5★–1★ breakdown, price and Best Sellers Rank for ASINs on 19 Amazon marketplaces
- [Amazon Seller Central Review Scraper & Monitor](https://apify.com/k-data-lab/amazon-seller-central-review-scraper): export and monitor your brand's customer reviews from Seller Central (US, EU, JP, IN), with order ID and photos; you sign in yourself
- [Google Play Scraper API](https://apify.com/k-data-lab/google-play-scraper): app details, reviews and search results from Google Play, no login; pairs with the Play ads above
- [Agoda Scraper](https://apify.com/k-data-lab/agoda-scraper): hotel prices, room offers and guest reviews from Agoda
- [Korean Music Chart API](https://apify.com/k-data-lab/korean-music-chart-scraper): Melon, Genie, Bugs, FLO and VIBE charts in one table, with all-kill detection
- Single-platform K-pop chart actors: [Melon](https://apify.com/k-data-lab/melon-scraper) · [Genie](https://apify.com/k-data-lab/genie-scraper) · [Bugs](https://apify.com/k-data-lab/bugs-scraper) · [FLO](https://apify.com/k-data-lab/flo-scraper) · [VIBE](https://apify.com/k-data-lab/vibe-scraper)

#### 💬 Feedback

Missing a field or found a wrong value? Open an issue on the actor's **Issues** tab.

Tags: google ads transparency, competitor ad monitoring, new ads alert, google ads transparency center api, google ads library, google ad library scraper, competitor ads, ad spy tool, google ads
scraper, youtube ads, google shopping ads, ad creatives, ppc competitor research, advertiser lookup

# Actor input Schema

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

What to look up, one per item. A website domain (nike.com) returns every advertiser's ads pointing to that site. A brand or company name (HubSpot) is matched to the verified advertiser with the most ads. An advertiser ID (AR…) or a Transparency Center link (advertiser, domain search or single ad) is used as is. Example: \["nike.com", "HubSpot"].

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

Only ads shown in this country: a two-letter country code, or "anywhere" for all countries. A Transparency Center link with its own region keeps that region. Example: "US", "GB", "DE" or "anywhere".

## `format` (type: `string`):

Only ads of this format: "ALL", "TEXT", "IMAGE" or "VIDEO". Example: "VIDEO" for YouTube creatives.

## `platform` (type: `string`):

Only ads shown on this Google product: "ALL", "GOOGLE_SEARCH", "YOUTUBE", "GOOGLE_SHOPPING", "GOOGLE_MAPS" or "GOOGLE_PLAY". Example: "YOUTUBE".

## `dateFrom` (type: `string`):

Only ads shown on or after this date (YYYY-MM-DD). Example: "2026-01-01". Leave empty for no limit.

## `dateTo` (type: `string`):

Only ads shown on or before this date (YYYY-MM-DD). Example: "2026-06-30". Leave empty for today.

## `maxAdsPerQuery` (type: `integer`):

Stop after this many ads for each item in queries. Big brands have tens of thousands of ads. Example: 50 for a quick look, 1000 for a full export.

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

true = also open each ad: headline and description, landing page URL, YouTube video ID, every variation, each country it ran in with first/last shown dates, EU impression ranges by platform, and topic. Charged as an extra Ad details event per ad. Example: true when you need ad copy or landing pages; false (default) for the ad list only.

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

true = return only ads earlier runs of this monitor have not returned yet, so a scheduled run gives just the competitor's new ads. Ad IDs are remembered per query and filters in a key-value store in your own account (k-data-lab-google-ads-seen); skipped ads are never charged. The first run returns everything. maxAdsPerQuery is then how many ads are checked per query. Not used in advertisers mode. Example: true for a daily monitor.

## `advertisersPerName` (type: `integer`):

How many matching advertisers to take for a brand or company name. Leave empty for 1 in ads mode and 10 in advertisers mode. Only advertisers whose name has every word you typed as a whole word count; the brand's own account (e.g. Nike, Inc.) comes first, then the most ads. Example: 3. Use a domain instead to get every advertiser running ads for a website.

## `mode` (type: `string`):

"ads" (default) scrapes ads. "advertisers" does not scrape ads: for a brand name it lists matching advertisers (up to advertisersPerName, 10 if empty) with verified country and ad count, the brand's own account first; for a domain it lists every advertiser found in the domain's first 200 ads. Example: "advertisers" to find a brand's advertiser IDs first.

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

Proxy used for ad previews and whenever Google slows down direct requests. The default Apify Proxy works well; keep the default. Example: {"useApifyProxy": true}.

## `debug` (type: `boolean`):

true = save the raw preview of each detailed ad to the run's key-value store (DEBUG\_<adId>) for troubleshooting. Example: false (default) for normal runs.

## Actor input object example

```json
{
  "queries": [
    "nike.com",
    "HubSpot"
  ],
  "region": "anywhere",
  "format": "ALL",
  "platform": "ALL",
  "maxAdsPerQuery": 20,
  "includeDetails": false,
  "onlyNewAds": false,
  "mode": "ads",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debug": 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": [
        "nike.com",
        "HubSpot"
    ],
    "maxAdsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("k-data-lab/google-ad-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": [
        "nike.com",
        "HubSpot",
    ],
    "maxAdsPerQuery": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("k-data-lab/google-ad-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": [
    "nike.com",
    "HubSpot"
  ],
  "maxAdsPerQuery": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call k-data-lab/google-ad-library-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,k-data-lab/google-ad-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/6OKVPkdST50aS6klL/builds/9cynbHoahVeeb1MRh/openapi.json