Google Ads Transparency Scraper

Give it a brand name, a landing domain or a Google advertiser id and it returns the ads Google publishes in its Ads Transparency Center as JSON: one row per ad with the advertiser's verified name and country, format (text, image, video), first and last day shown, days shown, regions and the archived ad image. From $1.80 per 1,000 ads; you pay only for rows you get.

$1.80 per 1,000 ads on the Free plan, down to $1.35 on higher plans

Why this actor

• Decoded creative without OCR: headline, description, display URL, sitelinks, Shopping product title and YouTube video id.
• Impression ranges per EU region and surface, and political ad spend.
• Monitor mode returns ads that started and ads that stopped since your last run.
• Reads the Transparency Center's own data endpoint, 100 ads per request, no browser. Input names of the leading actor are accepted.

What you get

Ad row (rowType: "ad"): one ad creative.

A decoded text ad adds:

Advertiser row (rowType: "advertiser", mode advertisers): one verified advertiser with advertiserId, advertiserName, advertiserCountry, adsMin / adsMax (approximate number of ads), advertiserUrl, and for name searches the matchingDomains Google suggests.

Monitor rows (mode monitor): per advertiser and run one summary row (status baseline, changed or unchanged; activeAds, newAds, resumedAds, stoppedAds, previousCheckAt), and one ad-change row per ad with changeType new (first shown since the last check), resumed (an older ad active again) or stopped (not shown for activeWithinDays days), with the ad fields above.

Sample row (from the README example; long text shortened, lists cut to two items):

{
  "rowType": "ad",
  "platform": "google-ads-transparency",
  "advertiserId": "AR04217635482122584065",
  "advertiserName": "Spotify USA Inc",
  "advertiserNameWithheld": false,
  "advertiserCountry": "US",
  "creativeId": "CR08508353801336389633",
  "adUrl": "https://adstransparency.google.com/advertiser/AR04217635482122584065/creative/CR08508353801336389633?region=GB",
  "format": "video",
  "firstShown": "2025-03-18",
  "lastShown": "2026-10-22",
  "daysShown": 520,
  "regionsShown": [
    "GB",
    "FR"
  ],
  "detailed": true,
  "impressionsMin": 500000,
  "impressionsMax": 600000,
  "regionStats": [
    {
      "region": "FR",
      "firstShown": "2025-03-25",
      "lastShown": "2026-10-21",
      "impressionsMin": 40000,
      "impressionsMax": 45000,
      "platforms": [
        {
          "platform": "youtube",
          "impressionsMin": 35000,
          "impressionsMax": 40000
        }
      ]
    }
  ],
  "contentKind": "video",
  "youtubeVideoId": "2BfJuvCtfEI",
  "youtubeUrl": "https://www.youtube.com/watch?v=2BfJuvCtfEI",
  "searchTerm": "AR04217635482122584065",
  "matchedBy": "advertiser"
}

Price

Live Apify price on 2026-11-03, per 1,000 rows, by Apify plan. You pay only for rows delivered; error and summary rows marked free in the README cost nothing. Plus $0.001 per GB of memory when a run starts.

Use cases

• Competitor ad intelligence: every ad a competitor ran this quarter, by country, format and surface, with the copy of its text and Shopping ads.
• New-ad alerts: schedule monitor mode daily and get only the ads that started or stopped.
• Brand protection: find advertisers that bid on your brand name or point ads at look-alike domains.
• EU reach estimates: impression ranges per country and surface (DSA data) for any advertiser.
• Political ad research: election ads with spend and impression ranges.

Run it from code or an AI agent

Actor ID arcadium/google-ads-transparency. Set APIFY_TOKEN to your Apify API token. The input below is the actor’s prefilled example; see the guide for every field.

curl -X POST "https://api.apify.com/v2/acts/arcadium~google-ads-transparency/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["nike.com"],"mode":"ads","maxAdsPerAdvertiser":20}'

// npm install apify-client
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('arcadium/google-ads-transparency').call({
  "searchTerms": [
    "nike.com"
  ],
  "mode": "ads",
  "maxAdsPerAdvertiser": 20
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

# pip install apify-client
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("arcadium/google-ads-transparency").call(run_input={
    "searchTerms": ["nike.com"],
    "mode": "ads",
    "maxAdsPerAdvertiser": 20,
})
items = client.dataset(run.default_dataset_id).list_items().items  # apify-client 3.x returns a Run object
print(items)

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=arcadium/google-ads-transparency",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}

# pip install langchain-apify   (reads APIFY_API_TOKEN from the environment)
from langchain_apify import ApifyActorsTool

tool = ApifyActorsTool("arcadium/google-ads-transparency")
rows = tool.invoke({"run_input": {
    "searchTerms": ["nike.com"],
    "mode": "ads",
    "maxAdsPerAdvertiser": 20,
}})
# or give `tool` to an agent: create_react_agent(llm, [tool])

# pip install llama-index-readers-apify
import os
from llama_index.core import Document, VectorStoreIndex
from llama_index.readers.apify import ApifyActor

reader = ApifyActor(os.environ["APIFY_TOKEN"])
documents = reader.load_data(
    actor_id="arcadium/google-ads-transparency",
    run_input={
        "searchTerms": ["nike.com"],
        "mode": "ads",
        "maxAdsPerAdvertiser": 20,
    },
    dataset_mapping_function=lambda item: Document(text=str(item.get("description") or ""), metadata={"url": item.get("url")}),
)
index = VectorStoreIndex.from_documents(documents)

# pip install crewai crewai-tools langchain-apify   (reads APIFY_API_TOKEN from the environment)
from crewai import Agent
from crewai_tools import ApifyActorsTool

tool = ApifyActorsTool(actor_name="arcadium/google-ads-transparency")
researcher = Agent(
    role="Research analyst",
    goal="Answer with data collected by the tool",
    backstory="Uses public web data.",
    tools=[tool],
)

{
  "nodes": [
    {
      "name": "Run arcadium/google-ads-transparency",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4,
      "position": [
        0,
        0
      ],
      "parameters": {
        "method": "POST",
        "url": "https://api.apify.com/v2/acts/arcadium~google-ads-transparency/run-sync-get-dataset-items",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpHeaderAuth",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "{\"searchTerms\":[\"nike.com\"],\"mode\":\"ads\",\"maxAdsPerAdvertiser\":20}",
        "options": {
          "timeout": 300000
        }
      }
    }
  ],
  "connections": {}
}

// Extensions > Apps Script. Store your token once: Project Settings > Script properties > APIFY_TOKEN.
function importLastRun() {
  const token = PropertiesService.getScriptProperties().getProperty('APIFY_TOKEN');
  const url = 'https://api.apify.com/v2/acts/arcadium~google-ads-transparency/runs/last/dataset/items?status=SUCCEEDED&clean=true&format=json';
  const res = UrlFetchApp.fetch(url, { headers: { Authorization: 'Bearer ' + token } });
  const rows = JSON.parse(res.getContentText());
  if (!rows.length) return;
  const keys = Object.keys(rows[0]);
  const values = rows.map((r) => keys.map((k) => (typeof r[k] === 'object' ? JSON.stringify(r[k]) : r[k])));
  const sheet = SpreadsheetApp.getActiveSheet();
  sheet.clearContents();
  sheet.getRange(1, 1, 1, keys.length).setValues([keys]);
  sheet.getRange(2, 1, values.length, keys.length).setValues(values);
}

Tutorials

• Google Ads Transparency scraper: export a competitor’s ads with ad copy and regions

Limitations

• Only what the Transparency Center shows anonymously. Google keeps ads for about a year after they were last shown (political ads longer).
• Google archives most text ads as an image of the ad; for those headline stays empty and imageUrl holds the ad. Text ads that Google still renders (and Shopping ads) are decoded.
• Impression ranges exist only for EU/EEA regions and political ads; ad counts are Google's approximations ("~9,000").
• Region filters with a brand name pick the advertisers first: when a brand runs local entities, raise maxAdvertisersPerTerm or use the local advertiser id.
• The actor reads Google over Apify's shared datacenter proxy. When Google rate-limits that pool, the run retries with short pauses and, if the limit persists, stops and reports the remaining inputs as free blocked error rows instead of burning time. Run again later.

FAQ

How do I find an advertiser id? Run mode advertisers with the brand name, or open the advertiser on adstransparency.google.com and copy the AR... part of the link.

Why do I get ads of several advertisers for one brand? Big brands verify one advertiser per country entity. A name search uses the maxAdvertisersPerTerm best matches (name contains your text, then most ads); a domain search returns every advertiser whose ads point at the domain.

How does monitor mode decide that an ad stopped? An ad is active when Google shows it on one of the last activeWithinDays days. It is reported as stopped on the first run after it has not been shown for that long.

Something looks wrong in the output. Who do I tell? Open an issue on the actor page with the run link. We read them all.