# Google Ads Transparency Center API — Advertisers & Ads (`insight.solutions/google-ads-transparency-api`) Actor

Google's Ads Transparency Center as rows: give brand names, AR ids or domains and get each verified advertiser's profile and its ads — format, first and last shown, days shown, preview link, regions and variations. People advertising under their own name are excluded. No browser, no login, no key.

- **URL**: https://apify.com/insight.solutions/google-ads-transparency-api.md
- **Developed by:** [Insight Solutions](https://apify.com/insight.solutions) (community)
- **Categories:** Marketing, Business, Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 ad creatives

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 Center API — Advertisers & Ads

**Every ad a brand runs on Google, as rows.** Give this Actor brand names, advertiser ids or domains and get back each verified advertiser's **profile** — name, verified country, the Ads Transparency Center's own ad-count range, the formats and dates of its ads, its DUNS number — and **one row per ad**: format (text, image or video), **first and last shown**, the Center's **days-shown** count, the **preview link** or snapshot image, the ad's page in the Center, and optionally every **country it was shown in**. JSON, CSV or Excel.

The data is Google's own [Ads Transparency Center](https://adstransparency.google.com), the public register of ads by verified advertisers. This Actor asks the Center's own JSON interface for it — the same requests the Center's web page makes — so there is no browser, no login and no API key, and a 1,000-ad advertiser takes about six seconds.

**People are excluded by design.** The Center also verifies individuals who advertise under their own name; they never appear in a row. **$2.00 per 1,000 ads** and **$5.00 per 1,000 advertiser profiles** on the FREE tier.

### Try it in 30 seconds

This is the Store prefill; paste it and run:

```json
{ "advertisers": ["Nike", "Allbirds", "Duolingo", "Notion"], "region": "US", "maxAdsPerAdvertiser": 100 }
```

Four brand names, each resolved to its verified advertiser (`Nike` → *Nike, Inc.*, the advertiser with 9,000–10,000 ads, not the one-ad advertiser that is literally called "Nike"), then the 100 most recently shown ads of each in the US: **4 profile rows and up to 400 ad rows from 16 requests**, in seconds. On the test suite's fixtures it returns exactly 4 profiles and 400 ads for **$0.821**.

Ads of one format, for an advertiser id and a domain, shown since September:

```json
{
  "advertisers": ["AR16735076323512287233", "allbirds.com"],
  "region": "US",
  "formats": ["video"],
  "maxAdsPerAdvertiser": 200,
  "sinceDate": "2026-09-01"
}
```

Where an ad ran, every variation of it, and the advertiser's DUNS number:

```json
{ "advertisers": ["Nike"], "region": "anywhere", "maxAdsPerAdvertiser": 50, "includeRegions": true, "includeDuns": true }
```

**From code** — `client.actor("insight.solutions/google-ads-transparency-api").call(run_input={"advertisers": ["Nike"]})` with `apify-client`, or `POST https://api.apify.com/v2/acts/insight.solutions~google-ads-transparency-api/run-sync-get-dataset-items`.

### What comes back

An **ad** row — a real Nike text ad from the captures in our test suite (null columns cut):

```json
{
  "rowType": "ad",
  "input": "Nike",
  "resolvedBy": "suggestion",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "creativeId": "CR03708909800050917377",
  "format": "text",
  "firstShown": "2022-11-30",
  "lastShown": "2026-11-03",
  "daysShown": 1377,
  "snapshotImageUrl": "https://tpc.googlesyndication.com/archive/simgad/3393474210464605364",
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR03708909800050917377?region=US",
  "region": "US"
}
```

An image or video ad carries `previewUrl` instead — the Center's own signed preview link, exactly as the Center returns it (`https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integrity-transparency&…&sig=…`). With `includeRegions` each ad also gets `"regions": ["US", "CA"]`, `"variationCount": 3` and `"variationPreviews": [ … ]`.

After an advertiser's ads, its **advertiser** row:

```json
{
  "rowType": "advertiser",
  "input": "Nike",
  "resolvedBy": "suggestion",
  "advertiserId": "AR16735076323512287233",
  "name": "Nike, Inc.",
  "region": "US",
  "queryRegion": "US",
  "adCountMin": 9000,
  "adCountMax": 10000,
  "adsReturned": 100,
  "byFormat": { "text": 38, "image": 42, "video": 20 },
  "firstSeen": "2021-10-25",
  "lastSeen": "2026-11-03",
  "activeDays": 1836,
  "dunsNumber": "50957364",
  "transparencyUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233?region=US"
}
```

`adCountMin`/`adCountMax` are the Center's own range for the advertiser's whole library; `adsReturned`, `byFormat`, `firstSeen`, `lastSeen` and `activeDays` describe the ads this run returned. Each run ends with a free **summary** row (`advertisersResolved`, `adsByFormat`, `requests`), and anything that could not be returned — a name with no verified advertiser, an individual, a tie, a rate limit — is a free **diagnostic** row (`errorType`, `error`) instead of a charge.

### Use cases

- **Competitor ad libraries** — every live and past ad of the brands you compete with, by format, with first and last shown dates and a link to each one in the Center: what they run, how long a creative survives, when a new campaign starts.
- **Agency pitch research** — before a pitch, the prospect's whole Google ad footprint: how many ads, which formats, how recent, which countries (`includeRegions`).
- **Creative benchmarking** — long-running ads (`daysShown`) are the ones that work; sort a category's ads by it and read the winners.
- **Launch and campaign monitoring** — schedule it with `sinceDate` and get only what each brand started showing since the last run.
- **Lead lists of brands that advertise** — an advertiser with thousands of ads on Google has a paid-media budget; `name`, `region`, `adCountMax` and `dunsNumber` across a category is that list, company-level only.
- **Brand-safety and impersonation checks** — search your own domain and see which verified advertisers run ads that point at it.

To see which brands sponsor YouTube channels, podcasts and newsletters rather than buy Google ads, use our [Sponsor & Advertiser Finder](https://apify.com/insight.solutions/sponsorship-intelligence-api) — same company-level rows, from creators' published sponsor reads.

### How it compares

- **No browser — seconds, not minutes.** Tools that drive a headless browser through the Center's web page pay for its page loads and scripts on every ad. This Actor sends the Center's own JSON requests: about 200 ms and 26 KB per 40 ads.
- **Individuals filtered out.** The Center verifies people as well as companies, and a brand-name search returns both. Here, anyone advertising under their own name is skipped before a single one of their ads is read.
- **Names, ids and domains.** A brand name is resolved to the right verified advertiser (exact name first, then the largest ad library); an AR id is read directly; a domain goes through the Center's domain filter.
- **Billed per ad, not per run or per minute.** Failures, people, ties and rate limits are free rows.
- **Google's links, untouched.** Preview and snapshot links are copied exactly as the Center returns them; nothing is re-signed, rebuilt or proxied.

### Where the data comes from

Everything comes from Google's **Ads Transparency Center** (`adstransparency.google.com`), the register Google launched in 2023 of ads shown by **verified advertisers** across its surfaces — Search, YouTube, Display, Maps, Shopping and Play. Its records go back further than its launch: the oldest ad in our test captures was first shown in October 2021.

What the Center publishes, and this Actor returns: the advertiser's verified name and country, an approximate ad count, each ad's format, the dates it was first and last shown, the Center's count of days shown, the countries it was shown in, its variations and a preview.

What the Center does **not** publish for these ads, and this Actor therefore does not return: **no spend**, **no impressions**, no clicks, no landing-page analytics, and **no targeting** (the Center publishes audience details only for some ads shown in the EU, and this Actor does not read them). Political-ad reports are a separate part of the Center that this Actor does not read.

The Center's interface is called exactly as its own page calls it: the same `POST` requests to `adstransparency.google.com/anji/_/rpc/…`, from Apify's datacenter proxy. The Actor **never sends cookies** and never fetches the preview scripts themselves.

### How advertisers are resolved

| You type | What happens | `resolvedBy` |
|---|---|---|
| A brand name — `Nike`, `Allbirds`, `Notion` | The Center's advertiser search (40 suggestions), then the ranking below | `suggestion` |
| An AR id — `AR16735076323512287233` — or a Center advertiser link | Read directly. The name comes from its ads; the country and ad-count range from its own search entry | `id` |
| A domain — `nike.com`, `https://www.allbirds.com/` | The Center's domain filter: the ads that point at the domain, grouped by advertiser | `domain` |

The advertiser search matches loosely — "Nike" returns *Nikeson AB*, *Nikea GmbH* and people whose names happen to contain *Nike* — so the candidates are ranked, best first:

1. **The name matches.** Equal once legal forms and punctuation are dropped (`Nike, Inc.`, `NIKE SRL` and `Nike S.r.l.` all equal `Nike`), or starting with the name as whole words (`Notion Labs, Inc.` for `Notion`). Anything looser is not a match.
2. **The largest ad library** — the Center's ad-count range, highest first.
3. **The same verified country as `region`** (no preference for `anywhere`).

`maxAdvertisersPerName` of them are taken (1 by default). When the next one ties with the last one taken on all three — two `IRM Insurance` advertisers with one ad each, say — the best is still returned and a free `ambiguous` row lists every tied AR id with its country and ad-count range, so you can pass the id you mean.

**Individuals.** An advertiser whose name has no organisation marker — no legal form (Inc, LLC, GmbH, SRL, AB, Pty…), no business word (Group, Agency, Studio, Shop, Media, Labs, Insurance, Clinic…), no `&`, no digit — **and** has the shape of a person's name (two to four parts: one to three words in any script plus initials) is treated as a person. It gets no profile row and no ad rows; one free `individual-advertiser-skipped` row carries its AR id and verified country and nothing else. Over-filtering is the accepted cost: a brand whose verified name is just two plain words is skipped too — check the diagnostic rows. A single-word name is treated as a business.

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `advertisers` | string\[] | prefill: 4 brands | Brand names, AR ids (or Center advertiser links) and domains, one per line. At most 200 entries per run; duplicates are read once. Required. |
| `region` | string | `US` | Two-letter country code (`UK` is read as `GB`), or `anywhere`. |
| `formats` | string\[] | `[]` (all) | Any of `text`, `image`, `video`. With two formats, each gets half the per-advertiser limit and a format that runs out passes its share on. |
| `maxAdsPerAdvertiser` | integer | 200 (prefill 100) | 1–5,000 ads per advertiser (per domain, for a domain entry). 40 per request. |
| `maxAdvertisersPerName` | integer | 1 | 1–10 matching advertisers per brand name, best first. |
| `includeRegions` | boolean | `false` | One extra lookup per ad: `regions`, `variationCount`, `variationPreviews`. Doubles the requests, not the price. |
| `includeDuns` | boolean | `false` | `dunsNumber` on advertiser rows, from the Center's advertiser-to-DUNS list, read once per run. |
| `sinceDate` | string | — | `2026-09-01`: only ads last shown on or after it. |
| `untilDate` | string | — | `2026-10-31`: only ads first shown on or before it. |
| `maxConcurrency` | integer | 4 | Requests in flight at once (1–10). |
| `maxRunSecs` | integer | 240 | 30–3,600. Rows already returned are kept — and billed — when it runs out. |
| `proxyConfiguration` | object | `{ "useApifyProxy": true }` | Apify datacenter proxy by default. |

A region that is not a country, a format that does not exist, a date that is not a date, an `untilDate` before `sinceDate`, or an empty list fails the run **before a single request**, with a free row saying what was wrong. One unreadable entry among good ones is a free `invalid-input` row and the rest are read.

### Output reference

Every row has the same columns, `null` where a column does not apply, so the dataset exports as one table. `rowType` is `ad`, `advertiser`, `summary` or `diagnostic`. The dataset has three views: **Ads**, **Advertisers** and **Could not return**.

**On every row:** `ok`, `rowType`, `input` (your entry as typed — null if the entry itself reads as a person's name), `errorType`, `error`, `scrapedAt`.

**Ad rows** (paid): `advertiserId`, `advertiserName`, `creativeId`, `format`, `firstShown`, `lastShown` (UTC days), `daysShown`, `previewUrl`, `snapshotImageUrl`, `adUrl`, `region` (the region you queried), `resolvedBy`, and with `includeRegions`: `regions[]` (ISO-2), `variationCount`, `variationPreviews[]`.

**Advertiser rows** (paid, after the advertiser's ads): `advertiserId`, `name`, `region` (the advertiser's verified country), `queryRegion`, `adCountMin`, `adCountMax`, `adsReturned`, `byFormat{text,image,video}`, `firstSeen`, `lastSeen`, `activeDays`, `dunsNumber`, `transparencyUrl`, `resolvedBy`.

**Summary row** (free, last): `entries`, `advertisersResolved`, `adsByFormat`, `requests`, `diagnostics`, `diagnosticTypes`.

**Diagnostic rows** (free):

| `errorType` | Meaning |
|---|---|
| `invalid-input` | An entry that is too long; a region, format or date that is not valid (the run then fails). |
| `advertiser-not-found` | No verified advertiser matches the name; an AR id or domain with no ads in the region, formats and dates asked for. |
| `individual-advertiser-skipped` | The match is a person advertising under their own name. Carries `advertiserId` and `region` only. |
| `ambiguous` | Several advertisers match equally well; the best is returned and `candidates` lists the ids. |
| `rate-limited` | The Center answered 429 or a web page instead of data, three times (two retries, fresh session each time). |
| `timeout` | The run's time budget ran out. Rows already returned are kept. |
| `rpc-error` | The Center refused a request or answered without the data this Actor reads; also a per-ad lookup that failed. |
| `internal` | This Actor's own error. The run is then FAILED. |

### Pricing

| Event | What it is | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|---|
| `actor-start` | Once per run, only after the run has returned a paid row | $0.001 | $0.001 | $0.001 | $0.001 |
| **`ad`** | One ad creative | **$0.002** | **$0.002** | **$0.0016** | **$0.0012** |
| `advertiser` | One verified advertiser's profile | $0.005 | $0.005 | $0.004 | $0.003 |

**$2.00 per 1,000 ads**, plus **$5.00 per 1,000 advertiser profiles**.

| Run | Cost |
|---|---|
| The prefill as the offline test suite runs it — 4 profiles, 400 ads | **$0.821** |
| One advertiser, 1,000 ads | **$2.006** |
| The same with `includeRegions` | **$2.006** — twice the requests, same price |
| 12 brands × 200 image and video ads | **≈ $4.86** |
| 1,000 ads at GOLD | **$1.20** + profiles |
| Ten names that match no verified advertiser | **$0.00**, SUCCEEDED |

Charging is charge-after-push: rows are in your dataset before the event is recorded. An advertiser's profile is pushed **after** its ads and its price is set aside before its first ad, so a run that reaches `ACTOR_MAX_TOTAL_CHARGE_USD` stops reading, still delivers the profile of every advertiser whose ads it returned, never bills a profile without its ads, and finishes SUCCEEDED saying so. Never charged: summary and diagnostic rows, individuals, ads outside your dates, a run that returns nothing (start fee included). A run whose names all fail to resolve is SUCCEEDED — "4 names, none resolved to a verified advertiser … Nothing was charged."

### Limits

- **Ad counts are the Center's ranges.** `adCountMin`–`adCountMax` ("9000"–"10000") is how the Center itself rounds an advertiser's library; this Actor does not count the whole library unless you walk it.
- **`daysShown` is the Center's own count** of days an ad was shown, as the Center reports it — not computed here, and never more than the first-to-last span.
- **Previews are Google-hosted and expire.** `previewUrl`, `snapshotImageUrl` and `variationPreviews` are Google's links, signed by Google, passed through untouched; they render through Google's own preview script and may stop working after a while. Re-run to refresh them. `adUrl` (the Center's page) does not expire.
- **People who advertise under their own name are excluded by design**, and a brand whose verified name looks like a person's (two plain words, no company suffix) is excluded with them. An AR id or a domain whose ads turn out to belong to a person is skipped the same way.
- **Dates are filtered here.** The Center has no working date filter, so ads are read newest last-shown first and those outside `sinceDate`/`untilDate` are dropped before they are returned (and never billed); a page entirely older than `sinceDate` ends the walk. At most 130 pages are walked per advertiser and format.
- **Limits per run:** 5,000 ads per advertiser, 10 advertisers per name, 200 entries, `maxRunSecs` up to 3,600 s.
- **Rate limits.** The Center answers Apify's datacenter proxy. A 429 or a web page in place of data is retried **at most twice**, each after a pause and from a fresh proxy session, and is then a free `rate-limited` row; the rest of the run goes on.
- **Regions.** A country is sent as the Center's own number (the United States is 2840); `anywhere` sends no region.
- The upstream formats may change: this Actor reads the Center's JSON as it is served today, and returns a free `rpc-error` row rather than a wrong one when an answer no longer has the data it expects.
- Not affiliated with Google. "Google", "Ads Transparency Center" and every advertiser name are used descriptively, to say where the data comes from and what it describes.

### Use it from an AI agent, or from code

One JSON object in, one flat array out — the shape agent runtimes want. The Actor runs with **limited permissions** and **pay-per-event** pricing, as an ordinary on-demand run, so it works over the Apify MCP server (`mcp.apify.com`) and with agentic (x402) payments. The **Integrations** tab pushes results to Slack, a webhook, Zapier, Make, Google Sheets, Snowflake or BigQuery, and Apify Schedules run it unattended — with `sinceDate`, each run returns only what is new.

```bash
curl -X POST "https://api.apify.com/v2/acts/insight.solutions~google-ads-transparency-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"advertisers":["Nike","allbirds.com"],"region":"US","formats":["image","video"],"maxAdsPerAdvertiser":100}'
```

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/google-ads-transparency-api").call(run_input={
    "advertisers": ["Nike", "Allbirds", "Duolingo"],
    "region": "US",
    "maxAdsPerAdvertiser": 200,
    "sinceDate": "2026-09-01",
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["rowType"] == "ad":
        print(row["advertiserName"], row["format"], row["firstShown"], row["lastShown"], row["daysShown"], row["adUrl"], sep=" | ")
    elif row["rowType"] == "advertiser":
        print(row["name"], row["region"], row["adCountMin"], row["adCountMax"], row["byFormat"])
```

**Building an app with Lovable?** Apify's Lovable connector runs any Actor from inside a Lovable project with your Apify token. Connect Apify in Lovable once, then ask it: *"Use Apify to run insight.solutions/google-ads-transparency-api on my competitors and build an ad-library tracker around the results."* At the default settings a run of a few brands finishes well inside Lovable's 300-second synchronous limit, and every result is one JSON object per row, so the generated app needs no extra parsing. Usage bills to the Apify account whose token is connected.

### FAQ

**Why did "Nike" not return the advertiser called exactly "Nike"?**
Because there are several: the Center lists a one-ad advertiser named "Nike", *Nike, Inc.* with 9,000–10,000 ads, and Italian *NIKE SRL* entities. Legal forms are ignored when names are compared, so all of them match, and the largest ad library wins. Raise `maxAdvertisersPerName` to get more of them, or pass an AR id.

**How do I find an advertiser's AR id?**
Every advertiser row has it (`advertiserId`), and it is the `AR…` part of the advertiser's page address in the Center. An `ambiguous` row lists the ids of the tied candidates.

**Can I see how much a brand spends?**
No — the Center does not publish spend or impressions for these ads, so neither does this Actor. What you get is what ran, when, where and for how long.

**Why is `daysShown` smaller than the gap between `firstShown` and `lastShown`?**
`daysShown` is the Center's own count of the days the ad was actually shown; an ad paused for a month keeps its first and last dates but not those days.

**A preview link stopped working.**
Preview links are Google's, signed and short-lived. Re-run the Actor for fresh ones, or open `adUrl`, the Center's own page for the ad.

**Why was an advertiser I asked for skipped as an individual?**
Its verified name reads as a person's — two or three plain words with no company suffix. That rule removes every sole trader and creator who advertises under their own name, and occasionally a brand whose legal name is just two words. Nothing is charged for it.

**Does a domain search find every advertiser of that brand?**
It finds the ads the Center associates with that domain, grouped by advertiser — often the brand itself, sometimes resellers and agencies too. For one brand's own library, its name or AR id is the more exact entry.

### Legal and data-protection notes

- **Public data only.** Everything this Actor reads is what Google's Ads Transparency Center shows any anonymous visitor. It never logs in, never sends cookies or tokens, never accepts credentials, and makes the same requests the Center's own page makes.
- **Organisations, not people.** Advertiser profiles and ads are returned for businesses and organisations only. Advertisers that are individuals are detected by their verified name and excluded before any of their ads is read; their diagnostic row carries an AR id and a country and nothing that names them.
- **Google's content is linked, not copied.** Ad previews and snapshots are Google-hosted links passed through unchanged; the Actor does not download, store or re-host ad creatives.
- **We are not a data broker.** This Actor holds no database and sells no list. It reads the Center on demand and writes the result to *your* dataset on *your* account.
- **Not affiliated with, endorsed by or sponsored by** Google or any advertiser named in the output. Names and trademarks are used descriptively.
- **You are responsible for how you use the output**, including any use of ad creatives (which belong to their advertisers) and any outreach to advertisers, under copyright, the GDPR, the CCPA, ePrivacy, CAN-SPAM and applicable marketing law. Nothing here is legal advice.

### Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

**Video, audio & social**

- [YouTube Transcript Scraper & API — Captions to Text, SRT & VTT](https://apify.com/insight.solutions/youtube-transcript-api) — captions as timed segments, text, SRT or VTT, with language fallback and translation.
- [YouTube Comments Scraper — Comments & Replies with Likes](https://apify.com/insight.solutions/youtube-comments-api) — comments and replies with likes, pinned and hearted flags, newest or top sort.
- [YouTube Channel Scraper — Videos, Shorts & Search](https://apify.com/insight.solutions/youtube-channel-api) — a channel's videos, Shorts and live streams, plus YouTube search.
- [Podcast Search, Episodes & Charts API](https://apify.com/insight.solutions/podcast-api) — Apple Podcasts search, charts and full episode feeds.
- [Bluesky Scraper](https://apify.com/insight.solutions/bluesky-scraper) — profiles, posts, followers and follows from the public AT Protocol API.
- [Telegram Channel Scraper — Posts, Views & Stats](https://apify.com/insight.solutions/telegram-channel-scraper) — posts, views and channel stats from public Telegram channels.
- [Substack Scraper](https://apify.com/insight.solutions/substack-scraper) — posts with full free text, comments and publication profiles.
- [Sponsor & Advertiser Finder — YouTube, Podcasts & Newsletters](https://apify.com/insight.solutions/sponsorship-intelligence-api) — which brands sponsor which YouTube channels, podcasts and Substack newsletters, with promo codes, offers and sponsor links, company-level only.
- [Hacker News API](https://apify.com/insight.solutions/hacker-news-api) — stories, comments, users, front page and a structured "Who is hiring?" parser from the official HN APIs.
- [GitHub Trending & Repo Scraper — Stars, Releases & Search](https://apify.com/insight.solutions/github-repos-api) — repository facts, trending lists, releases and search, no token needed for small runs.
- [Discourse Forum Scraper — Topics, Posts & Categories](https://apify.com/insight.solutions/discourse-forum-api) — topics, posts and categories from any Discourse community via its own JSON endpoints, usernames only.

**News, documents & the web**

- [Google News Scraper — Search, Topics & Real Article URLs](https://apify.com/insight.solutions/google-news-api) — news search and topic feeds with the publisher's real URL decoded.
- [Website to Markdown Converter & API — for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor) — any site as clean Markdown, text and heading-aware chunks.
- [WordPress Scraper — Posts & Pages from Any WP Site, No Login](https://apify.com/insight.solutions/wordpress-posts-api) — posts and pages from any WordPress site as clean text or Markdown, with categories, tags and images.
- [Website Metadata Extractor — Schema.org, Open Graph & JSON-LD](https://apify.com/insight.solutions/website-metadata-api) — any URL's meta tags, Open Graph, Twitter cards, hreflang, feeds, JSON-LD and microdata, with normalised Product, Article, Event and FAQ entities.
- [Subdomain Finder — Certificate Logs & DNS, No API Key](https://apify.com/insight.solutions/subdomain-finder-api) — every subdomain of a domain from certificate-transparency logs, resolved over DNS, with an optional live HTTP check.
- [Internet Archive Scraper & API — Search, Metadata & Files](https://apify.com/insight.solutions/internet-archive-api) — archive.org search, item metadata, files and reviews.
- [Wayback Machine Scraper — Archived URLs, Snapshots & Diffs](https://apify.com/insight.solutions/wayback-toolkit) — archived URL inventories, snapshots and text diffs between dates.
- [Website Technology Detector — Tech Stack Checker & Lookup](https://apify.com/insight.solutions/website-tech-detector) — the tech stack behind any site, with the evidence for each detection.
- [Domain Lookup API — DNS, WHOIS/RDAP, SSL & Providers](https://apify.com/insight.solutions/domain-intelligence-api) — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
- [SEO Audit Tool — Sitemap Crawl & On-Page Checker](https://apify.com/insight.solutions/seo-page-audit) — sitemap crawl with on-page checks, structured data and broken-link reports.
- [Keyword Suggestions Tool & API — Google, Bing & Amazon](https://apify.com/insight.solutions/keyword-suggestions-api) — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
- [Website Contact Scraper — Email, Phone & Socials Extractor](https://apify.com/insight.solutions/website-contact-extractor) — emails, phone numbers and social profiles from any list of websites.
- [Company Email Finder — Published Emails & Phones by Name](https://apify.com/insight.solutions/company-contact-finder) — company names in, each one's verified website with its business emails, phone numbers and social profiles out.
- [Web Search Results API](https://apify.com/insight.solutions/web-search-api) — Bing and DuckDuckGo organic results with snippets, no key, no browser.
- [Company Enrichment API](https://apify.com/insight.solutions/company-enrichment-api) — a domain in, a company profile out: firmographics, contacts, tech stack, DNS and hiring signal.
- [Company Dossier API](https://apify.com/insight.solutions/company-dossier-api) — one company in, twelve sections out: profile, tech, contacts, DNS, open roles, news, SEC filings, federal awards, recalls, YC batch and apps.
- [Press Release Scraper — GlobeNewswire, PR Newswire & More](https://apify.com/insight.solutions/press-releases-api) — GlobeNewswire and PR Newswire releases plus any newsroom feed, by keyword, company, ticker or subject.
- [Federal Register API](https://apify.com/insight.solutions/federal-register-api) — rules, proposed rules, notices and the Public Inspection desk with dockets, comment deadlines and CFR references.
- [Academic Papers Search API](https://apify.com/insight.solutions/academic-papers-api) — OpenAlex, Crossref, arXiv and PubMed in one row per paper: abstract, citations, open-access PDF, authors and venue.
- [RSS & Atom Feed Monitor](https://apify.com/insight.solutions/rss-feed-monitor) — any RSS, Atom or JSON feed (or an OPML file) in, only the new items out, with keyword filters and a webhook.
- [Website Change Monitor](https://apify.com/insight.solutions/website-change-monitor) — watch any pages, diff the text between runs, get change rows with added/removed lines, keyword alerts and a webhook.
- [Wikipedia & Wikidata API](https://apify.com/insight.solutions/wikipedia-api) — article text, search, daily pageviews and Wikidata entity facts, any language edition.

**Business, finance & jobs**

- [Congress Trades Tracker API — STOCK Act PTRs + SEC Form 4](https://apify.com/insight.solutions/congress-insider-trades-api) — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
- [Federal Contracts, Grants & Lobbying API](https://apify.com/insight.solutions/federal-contracts-grants-api) — SAM.gov opportunities, USAspending awards, Grants.gov notices and Senate lobbying filings in one schema.
- [SEC EDGAR API](https://apify.com/insight.solutions/sec-edgar-api) — filings, XBRL financials and full-text search by ticker or CIK.
- [Litigation Signals API — Lawsuits, Settlements & Investigations](https://apify.com/insight.solutions/litigation-signals-api) — lawsuits, settlements and investigations per public company from SEC 10-K, 10-Q and 8-K disclosures, press wires and SEC, FTC and DOJ notices, company-level only.
- [Startup Funding Rounds API — SEC Form D, Wires & News](https://apify.com/insight.solutions/funding-signals-api) — who just raised money: one row per funding round from SEC Form D filings, press wires and Google News, with amount, round, investors, industry and state, company-level only.
- [Clinical Trials & FDA API](https://apify.com/insight.solutions/clinical-trials-fda-api) — ClinicalTrials.gov studies plus openFDA recalls, labels, approvals, 510(k)s and adverse-event reports.
- [Product & Vehicle Recalls API](https://apify.com/insight.solutions/product-recalls-api) — CPSC, NHTSA, FDA and USDA recalls, vehicle complaints and ratings, plus a VIN decoder.
- [YC Companies List & Directory Scraper — Batches & Founders](https://apify.com/insight.solutions/yc-companies-directory) — the YC directory with founders and social links, filterable by batch, industry and hiring status.
- [Job Scraper for Greenhouse, Lever, Ashby & 10+ ATS Career Sites](https://apify.com/insight.solutions/ats-jobs-api) — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
- [Workday Jobs Scraper — All Postings from Any Workday Site](https://apify.com/insight.solutions/workday-jobs-api) — every posting on any Workday career site, with facets, search, posted dates and full descriptions.
- [Job Postings Monitor — New & Closed Roles, Hiring Alerts](https://apify.com/insight.solutions/job-postings-monitor) — new, closed and changed postings on the career sites you watch.
- [Hiring Signals API — Open Roles & Hiring Surge by Company](https://apify.com/insight.solutions/hiring-signals-api) — one row per company per run: open roles, what opened and closed, department and seniority breakdowns, and a hiring-surge flag.
- [Careers Page Scraper — Open Roles from Any Company's Site](https://apify.com/insight.solutions/careers-page-jobs-api) — open roles from any company's own careers site: domain in, the platform recognised (Eightfold, Phenom, Jibe, iCIMS, Google, Amazon, 14 ATSs) or the site's structured data read, one row per job.
- [Wellfound Jobs Scraper — Startup Roles, Salary & Equity](https://apify.com/insight.solutions/wellfound-jobs-api) — startup jobs from Wellfound's role listings, by role and city or remote: salary and equity as shown, remote policy, experience, and each startup's size, stage and badges, no recruiter contacts.
- [Remote Jobs API](https://apify.com/insight.solutions/remote-jobs-api) — RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy and more in one schema, deduplicated.
- [Shopify Products Scraper — Catalogue, Prices & Stock](https://apify.com/insight.solutions/shopify-products-api) — any Shopify store's catalogue, variants, prices and stock signals.
- [WooCommerce Products Scraper — Prices, Variants & Stock](https://apify.com/insight.solutions/woocommerce-products-api) — any WooCommerce store's catalogue, prices, variants and stock through its public Store API.
- [Price Tracker & Monitor — Any Retailer's Prices & Stock](https://apify.com/insight.solutions/price-tracker-api) — price, stock, list price and discount from any product URL, read from the page's structured data, with price-drop and restock rows between runs.
- [Rightmove Scraper — UK Listings for Sale & Rent by Area](https://apify.com/insight.solutions/rightmove-property-api) — UK property for sale and to rent by area from Rightmove's own search API: price, bedrooms, type, tenure, size, coordinates, photos, status and the agent branch, one row per listing.
- [Shopify App Store Scraper — Apps, Pricing, Ratings & Reviews](https://apify.com/insight.solutions/shopify-app-store-api) — Shopify App Store listings by category, collection or developer: pricing plans, ratings and merchant reviews.
- [Luma Events Scraper — Events by City, Category & Calendar](https://apify.com/insight.solutions/luma-events-api) — upcoming Luma events by city, category or calendar: dates, venue, price, capacity and organiser calendar, no host names.
- [Eventbrite Scraper — Events by City, Category & Organizers](https://apify.com/insight.solutions/eventbrite-events-api) — upcoming Eventbrite events by city, category, online or organiser, with the organising companies behind them: dates, venue, price, ticket status, followers and website, no browser, individuals never named.
- [Meetup Scraper — Upcoming Events & Group Stats](https://apify.com/insight.solutions/meetup-events-api) — upcoming events of the Meetup groups you name, and the groups themselves: dates, venue, RSVPs, fee, member count, topics and ratings, no member data.
- [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — price drops, sales, restocks, sell-outs and new products on any Shopify store, one row per change.
- [Shopify Store Finder — Discover & Verify Stores by Niche](https://apify.com/insight.solutions/shopify-store-finder) — Shopify stores by niche and country, each verified on its own storefront, with product count, currency, country, price range and sample products.
- [Public Tenders API](https://apify.com/insight.solutions/public-tenders-api) — EU TED, UK Find a Tender and Contracts Finder notices by keyword, CPV code, country, stage and deadline.
- [Nonprofit Lookup & IRS 990 API — EIN, Financials, NTEE](https://apify.com/insight.solutions/nonprofit-990-api) — search US nonprofits and get EIN, NTEE code and multi-year Form 990 financials.
- [OpenStreetMap Places API](https://apify.com/insight.solutions/osm-places-api) — businesses and points of interest by category and area from OpenStreetMap: name, address, coordinates, website, phone, opening hours.

**Apps & games**

- [App Store & Google Play Reviews Scraper — Ratings & Replies](https://apify.com/insight.solutions/app-reviews-api) — reviews from both stores with ratings, versions and developer replies.
- [App Store Top Charts & App Search API](https://apify.com/insight.solutions/app-charts-api) — Apple top charts by country and genre, plus app search and details.
- [App Store Keyword Rank Tracker](https://apify.com/insight.solutions/app-store-keyword-rank-tracker) — where any app ranks for any keyword on the App Store and Google Play, with rank changes and ASO suggestions.
- [Steam Reviews Scraper — Reviews & Game Details](https://apify.com/insight.solutions/steam-reviews-api) — Steam reviews with playtime, helpfulness and game details.
- [Steam Game Data API](https://apify.com/insight.solutions/steam-store-stats-api) — prices, tags, review scores, live player counts and top charts.
- [Sports Scores & Schedules API](https://apify.com/insight.solutions/sports-scores-api) — scores, schedules, standings, teams and headlines for the NFL, NBA, MLB, NHL, soccer and more, no key.
- [App Store Monitor](https://apify.com/insight.solutions/app-store-monitor) — App Store and Google Play listings watched between runs: new versions with release notes, price, rating and listing changes, one row per change.

# Actor input Schema

## `advertisers` (type: `array`):

One per line: a **brand name** (`Nike` — resolved through the Center's own advertiser search to the verified advertiser that matches best), an **AR id** (`AR16735076323512287233`) or a Center advertiser link, or a **domain** (`nike.com` — searched through the Center's domain filter, which returns the ads that point at it). At most 200 entries per run; duplicates are read once.

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

Where the ads were shown: a two-letter country code (`US`, `GB`, `DE`, …; `UK` is read as `GB`), or `anywhere` for no region filter. Rows link to the Center's pages for this region.

## `formats` (type: `array`):

Only these formats: any of `text`, `image`, `video`. Empty (or all three) means every format. With two formats, each gets half of the per-advertiser limit, and a format that runs out hands its share to the other.

## `maxAdsPerAdvertiser` (type: `integer`):

How many ads are returned per advertiser (per domain, for a domain entry), newest last-shown first. The Center answers 40 per request, so 200 ads is 5 requests. Each ad is one `ad` row.

## `maxAdvertisersPerName` (type: `integer`):

How many verified advertisers to take for each brand name, best match first: the name itself (legal suffixes ignored), then the largest ad count, then the same country as `region`. Raise it to also read a brand's regional entities (`Nike, Inc.` and `NIKE SRL`). AR ids and domains are not affected.

## `includeRegions` (type: `boolean`):

Look each ad up once more to fill `regions` (every country the Center says it was shown in), `variationCount` and `variationPreviews`. One extra request per ad, so a run takes about twice as long. It costs time, not money: the `ad` price is the same.

## `includeDuns` (type: `boolean`):

Fill `dunsNumber` on advertiser rows from the Center's own advertiser-to-DUNS list, read once per run (about 300 KB). Not every advertiser has one.

## `sinceDate` (type: `string`):

Only ads last shown on or after this day (`2026-09-01`). The Center has no date filter of its own, so ads outside the dates are read and dropped before they are returned — never billed. Leave empty for no limit.

## `untilDate` (type: `string`):

Only ads first shown on or before this day (`2026-10-31`). With `sinceDate`, the ads that ran at any time inside the window. Leave empty for no limit.

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

How many requests are in flight at once, across advertisers and per-ad lookups (1–10).

## `maxRunSecs` (type: `integer`):

Wall-clock budget for the whole run. When it is reached the Actor stops reading, keeps — and bills — every row it already wrote (with each started advertiser's profile), and files a free `timeout` row for what it did not finish.

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

Apify datacenter proxy by default — the Center answers it, and every request goes through it. A rate-limited request is retried at most twice, each time from a fresh proxy session.

## Actor input object example

```json
{
  "advertisers": [
    "Nike",
    "AR16735076323512287233",
    "allbirds.com"
  ],
  "region": "US",
  "formats": [],
  "maxAdsPerAdvertiser": 100,
  "maxAdvertisersPerName": 1,
  "includeRegions": false,
  "includeDuns": false,
  "sinceDate": "2026-09-01",
  "untilDate": "2026-10-31",
  "maxConcurrency": 4,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Ads and advertiser profiles read from Google's public Ads Transparency Center, in one schema, plus summary and diagnostic rows. Delivered as JSON items in the default dataset.

# 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 = {
    "advertisers": [
        "Nike",
        "Allbirds",
        "Duolingo",
        "Notion"
    ],
    "region": "US",
    "formats": [],
    "maxAdsPerAdvertiser": 100,
    "includeRegions": false,
    "includeDuns": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insight.solutions/google-ads-transparency-api").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 = {
    "advertisers": [
        "Nike",
        "Allbirds",
        "Duolingo",
        "Notion",
    ],
    "region": "US",
    "formats": [],
    "maxAdsPerAdvertiser": 100,
    "includeRegions": False,
    "includeDuns": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("insight.solutions/google-ads-transparency-api").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 '{
  "advertisers": [
    "Nike",
    "Allbirds",
    "Duolingo",
    "Notion"
  ],
  "region": "US",
  "formats": [],
  "maxAdsPerAdvertiser": 100,
  "includeRegions": false,
  "includeDuns": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call insight.solutions/google-ads-transparency-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,insight.solutions/google-ads-transparency-api"
        }
    }
}
```

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/5P1l1JTNHwpkiqklt/builds/4hdvACgueuIhObgvQ/openapi.json