# Competitor Ad Footprint: Google + Meta Ads Checker (`transparent_meteorite/ad-footprint-by-domain`) Actor

Is this company advertising? See one row per domain from the public Google Ads Transparency Center and Meta Ad Library: ad counts, formats, platforms, first/last seen, regions, sample ads and a 0-100 footprint score. Monitor mode flags changes. No login.

- **URL**: https://apify.com/transparent_meteorite/ad-footprint-by-domain.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 domain footprints

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

## Competitor Ad Footprint: Google + Meta Ads Checker

**Competitor ad checker** for a list of domains: one row per company with its footprint in the public Google Ads Transparency Center and Meta Ad Library, with ad counts, formats, platforms, first and last seen dates, countries, sample ads and a 0-100 footprint score.

**This Actor vs alkausari_mujahid/google-ads-transparency-scraper:** that one is well-used for checking which domains have ever run Google Ads. This one also checks the Meta Ad Library, adds ad counts, formats, countries, sample ads and a 0-100 score, and has a monitor mode that returns a row only when a company's ads change.

![Competitor Ad Footprint: features, price and a real output row](https://api.apify.com/v2/key-value-stores/9BAn0msnxToXlD9TO/records/sf-ad-footprint-by-domain-banner-10140227.png)

[![Run it free on Apify](https://api.apify.com/v2/key-value-stores/9BAn0msnxToXlD9TO/records/sf-cta.png)](https://console.apify.com/actors/zYVAgQCjL2J3BHe5u/input)

| Price per 1,000 domains | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| **This Actor** | **$3.00** | **$2.50** | **$2.20** | **$1.80** |

<sub>Pay per event, no monthly rental. Prices read from each Actor's public Apify pricing on 2026-10-13; check the Pricing tab for the current figure.</sub>

![Competitor Ad Footprint sample output table from a real run](https://api.apify.com/v2/key-value-stores/9BAn0msnxToXlD9TO/records/sf-ad-footprint-by-domain-output-10140227.png)

**Is this company advertising, where, and how much?** Give it a list of domains. You get one row per company with its footprint in the public **Google Ads Transparency Center** and **Meta Ad Library**: ad counts, formats, platforms, first and last seen dates, countries, sample ads and a 0-100 footprint score. **$3 per 1,000 domains**, no login, no API key.

### What does it do?

For each domain (for example `hubspot.com`) the actor:

- **Google Ads Transparency Center** (Search, YouTube, Display, Shopping): finds every creative that points to the domain, the verified advertisers behind them, the ad count, the split by format (text, image, video), first and last shown dates and the countries the ads ran in.
- **Meta Ad Library** (Facebook, Instagram, Messenger, Threads, Audience Network): finds the advertiser Pages whose ads link to the domain (or whose name matches the brand), then counts their active ads and reads platforms and start dates.
- **LinkedIn Ad Library**: LinkedIn's robots.txt forbids automated access, so the actor does **not** fetch it. Each row carries a ready `linkedin.libraryUrl` you can open by hand, and `sourceStatus.linkedin` says `unavailable`.
- Adds up to 3 sample ads per library (text, dates, preview and library link) and a **footprint score** from 0 (no ads anywhere) to 100 (heavy, recent, multi-channel advertiser).
- **Monitor mode** (`onlyNew`): schedule it and get a row only when a company's ad counts or newest ads change.

### Who is it for?

- **Agencies qualifying leads**: a company already spending on Google and Meta is a warm lead for ads management; one with zero ads is a pitch for getting started.
- **Competitor research**: see which competitors advertise, on which channels, since when, and get alerted when they launch new campaigns.
- **Sales and RevOps**: enrich a CRM account list with an "is advertising" flag and score.

### Input

| Field | What it does | Default |
|---|---|---|
| `domains` | Domains or website URLs, one per line | `["hubspot.com"]` |
| `startUrls` | Paste website URLs instead (domain is taken from each) | empty |
| `brandNames` | Optional brand keyword per domain, same order (for example `Blue Bottle Coffee`) | taken from the domain |
| `sources` | `google`, `meta`, `linkedin` | all three |
| `country` | Two-letter country where ads ran, or `ANY` | `US` |
| `includeAdSamples` | Sample ads per library (first 3 included in the price) | `3` |
| `maxItems` | Max domains per run | `100` |
| `onlyNew` | Monitor mode: only domains that changed since the last run | `false` |
| `stateStoreName` | Key-value store that remembers the last snapshot | `ad-footprint-state` |
| `proxyConfiguration` | Apify Proxy (residential by default, Meta blocks datacenter IPs) | residential US |

An empty input `{}` checks `hubspot.com`.

#### Example inputs (presets)

1. **Qualify a lead list:** `{"domains": ["hubspot.com", "notion.so", "basecamp.com"], "includeAdSamples": 0}`
2. **Competitor deep check in the UK with more samples:** `{"domains": ["monzo.com", "revolut.com"], "country": "GB", "includeAdSamples": 6}`
3. **Weekly competitor alert (schedule it):** `{"domains": ["asana.com", "monday.com", "clickup.com"], "onlyNew": true, "stateStoreName": "pm-tools-watch"}`

### Output sample

```json
{
  "domain": "hubspot.com",
  "brandName": "hubspot",
  "advertisingAnywhere": true,
  "google": {
    "advertiserIds": ["AR10072600183532683265", "AR16516028954147028993"],
    "advertisers": [{ "id": "AR10072600183532683265", "name": "Hubspot, Inc.", "creativesInSample": 36 }],
    "adsCount": 1000, "adsCountMax": 2000, "adsCountIsRange": true,
    "formats": ["text", "image", "video"], "formatCounts": { "text": 800, "image": 71, "video": 300 },
    "firstShown": "2021-10-25", "lastShown": "2026-10-13",
    "regions": ["US", "CA", "MX", "FR", "DE"],
    "transparencyUrl": "https://adstransparency.google.com/?domain=hubspot.com&region=US"
  },
  "meta": {
    "pageNames": ["HubSpot", "HubSpot Academy"], "pageIds": ["6039999393", "151402415246767"],
    "activeAdsCount": 129, "platforms": ["facebook", "instagram", "messenger", "threads"],
    "mediaTypes": ["video", "image"], "oldestActiveStart": "2026-01-22", "newestStart": "2026-10-08",
    "libraryUrl": "https://www.facebook.com/ads/library/?active_status=active&ad_type=all&country=US&q=hubspot&search_type=keyword_unordered"
  },
  "linkedin": { "adsCount": null, "latestAdDate": null, "libraryUrl": "https://www.linkedin.com/ad-library/search?accountOwner=hubspot" },
  "sourceStatus": { "google": "ok", "meta": "ok", "linkedin": "unavailable" },
  "samples": [{ "source": "meta", "advertiserName": "HubSpot", "adId": "1666749958340789", "format": "video", "text": "HubSpot Smart CRM keeps notes and next steps current, so you...", "url": "https://www.facebook.com/ads/library/?id=1666749958340789" }],
  "footprintScore": 97,
  "checkedAt": "2026-10-13T20:10:00.000Z"
}
```

`sourceStatus` per library: `ok` (answered, even with zero ads), `error` (failed this run, see `sourceErrors`), `skipped` (not requested), `unavailable` (LinkedIn). The **Overview** table view shows the key columns; OUTPUT in the key-value store has run stats.

### Pricing

Pay per event. You pay only for domain rows delivered. A domain where no library answered, and an unchanged domain in monitor mode, is never charged.

| Apify plan | Per domain | Per 1,000 domains |
|---|---|---|
| Free | $0.0030 | $3.00 |
| Bronze | $0.0025 | $2.50 |
| Silver | $0.0022 | $2.20 |
| Gold and above | $0.0018 | $1.80 |

Up to 3 sample ads per library are included. Samples beyond 3 per library cost $0.0005 each (`ad-sample` event). The run stops before it would pass the maximum cost you set.

### Use it via API, schedules or AI agents (MCP)

- **API:** `POST https://api.apify.com/v2/acts/transparent_meteorite~ad-footprint-by-domain/run-sync-get-dataset-items?token=YOUR_TOKEN` with `{"domains": ["hubspot.com"]}` as the body.
- **Schedules:** set `onlyNew: true` and a watch list, schedule weekly, and send new rows to Slack, email or a sheet with an Apify integration.
- **MCP / AI agents:** add `https://mcp.apify.com?actors=transparent_meteorite/ad-footprint-by-domain` to Claude, Cursor or any MCP client and ask "which of these 20 companies advertise on Google and Meta?".

### Limits (honest)

- **Google ad counts are ranges** for big advertisers (the Transparency Center shows "1,000-2,000"). `adsCount` is the lower bound, `adsCountMax` the upper, `adsCountIsRange` tells you which. Small advertisers get exact counts.
- Google `firstShown` / `lastShown` cover the most recent 40 creatives for the domain (Google lists newest first), so `firstShown` can be later than the advertiser's very first ad.
- The Google domain search also lists other advertisers whose ads point at the domain (for example landing pages hosted on it); `advertisers` shows each with its creative count, owner first.
- **Meta** counts active ads in the chosen country for up to 3 matched advertiser Pages. Brands with generic names may need `brandNames`. Meta dates are taken from the first 30 ads per Page.
- **LinkedIn is not fetched** (robots.txt). The row gives the library link only.
- About 6-15 seconds per domain with all sources.

### Run in 30 seconds

1. Open the Actor page and click **Try for free** (or **Start** if you are signed in).
2. Paste this example into the JSON tab of the input:

```json
{
  "domains": ["hubspot.com", "notion.so"],
  "country": "US",
  "includeAdSamples": 3
}
```

3. Click **Start**. Each domain takes roughly 6 to 15 seconds with all sources, so this run is done in well under a minute.
4. Open the **Output** tab for the Overview table, or use **Export** to download CSV, Excel or JSON. The full record for each company, including sample ads, is in the JSON export.

### Why check the ad libraries by domain

Both Google and Meta publish ad transparency data for anyone to read, but each library is searched one company at a time through a web page, and each answers in a different shape. The Google Ads Transparency Center groups ads by verified advertiser, while the Meta Ad Library groups them by Facebook Page. Joining the two for a list of companies is slow by hand. This actor runs the same public lookups for each domain and returns one flat row, so that a list of 50 or 500 companies can be compared in a spreadsheet.

The result answers three practical questions:

- **Is the company advertising at all?** `advertisingAnywhere` is true when at least one library that answered shows ads.
- **Where and in what format?** The `google` block has formats and regions, the `meta` block has platforms and media types.
- **Is it recent?** `lastShown` for Google, `newestStart` for Meta and the `footprintScore` all react to recent activity.

### Use cases in detail

**Agency lead qualification.** Take a purchased or exported account list, paste the domains, and sort by `footprintScore`. Companies with a high score already spend on both channels, so the pitch is optimisation. Companies with `advertisingAnywhere` false are candidates for a first-campaign offer. Use `includeAdSamples` of 0 to keep this run small.

**Competitor watch.** Put your five closest competitors in a watch list, set `onlyNew` to true, and schedule the actor weekly. A new row appears only when a competitor's ad counts or newest ads change, which is the signal that a campaign launched or ended.

**Sales enrichment.** Add the footprint score and the two library links to each account in a CRM. A rep can open `google.transparencyUrl` or `meta.libraryUrl` directly before a call and see the creatives the prospect is running.

**Market mapping.** Run a whole category, for example all project-management tools, and compare which channels and countries each vendor uses. Change `country` to see how the footprint differs between markets.

**Due diligence.** Check whether a brand that claims heavy marketing spend actually has an ad history, and how long ago the oldest active ads started.

### Input fields explained

- `domains` takes one domain per line. Full website URLs work too, and the domain is extracted.
- `startUrls` is the same input in the format other actors use. Each URL's domain is checked once.
- `brandNames` is optional and aligns with `domains` by position. Meta matches advertiser Pages by link to the domain or by brand name, so a distinctive brand name helps when the domain is generic. For example, a domain such as `bluebottlecoffee.com` can be paired with the brand `Blue Bottle Coffee`.
- `sources` selects among `google`, `meta` and `linkedin`. Leaving LinkedIn in only adds a library link and a status of `unavailable`, since the actor does not fetch that site.
- `country` is a two-letter code for the market where the ads ran, or `ANY`. It defaults to `US`.
- `includeAdSamples` accepts 0 to 20 samples per library and defaults to 3.
- `maxItems` accepts 1 to 5000 and defaults to 100.
- `onlyNew` turns on monitor mode, and `stateStoreName` names the key-value store that holds the last snapshot. Use one store name per watch list so lists do not overwrite each other.
- `proxyConfiguration` defaults to residential Apify Proxy because Meta rate-limits datacenter addresses. Google is requested directly first.

### Output fields reference

| Field | Meaning |
|---|---|
| `domain`, `brandName` | The checked domain and the brand keyword used for Meta |
| `advertisingAnywhere` | True when any library that answered shows ads |
| `footprintScore` | 0 to 100 summary of volume, recency and channels |
| `google.advertisers` | Verified advertisers behind ads for the domain, with creative counts |
| `google.adsCount`, `adsCountMax`, `adsCountIsRange` | Lower bound, upper bound, and whether Google reported a range |
| `google.formats`, `formatCounts` | Text, image and video creatives |
| `google.firstShown`, `lastShown`, `regions` | Dates and countries for the newest creatives |
| `google.transparencyUrl` | Link to the same lookup on Google |
| `meta.pageNames`, `pageIds` | Matched Facebook advertiser Pages |
| `meta.activeAdsCount` | Active ads in the chosen country across matched Pages |
| `meta.platforms`, `mediaTypes` | Where the ads run and in what format |
| `meta.oldestActiveStart`, `newestStart` | Start dates read from the first ads per Page |
| `meta.libraryUrl`, `linkedin.libraryUrl` | Links to open the library by hand |
| `sourceStatus` | `ok`, `error`, `skipped` or `unavailable` for each library |
| `samples` | Up to the requested number of sample ads with text, format, dates and a library link |
| `checkedAt` | Time of the check |

### More worked examples

**Compare a sector in a second market**

```json
{
  "domains": ["monzo.com", "revolut.com", "wise.com"],
  "country": "GB",
  "includeAdSamples": 5
}
```

**Meta only, with a brand override for a generic domain**

```json
{
  "domains": ["bluebottlecoffee.com"],
  "brandNames": ["Blue Bottle Coffee"],
  "sources": ["meta"],
  "country": "US"
}
```

**Weekly watch list**

```json
{
  "domains": ["asana.com", "monday.com", "clickup.com"],
  "onlyNew": true,
  "stateStoreName": "pm-tools-watch",
  "includeAdSamples": 0
}
```

### Tips

1. Run the first pass with `includeAdSamples` of 0 and add samples only for the companies that matter.
2. Check `sourceStatus` before trusting a zero. A zero with status `ok` means the library answered with no ads. A status of `error` means the lookup failed and the zero is not a finding; `sourceErrors` explains why.
3. For generic domain names, provide `brandNames` so the Meta match is correct.
4. Keep one `stateStoreName` per watch list.
5. Read ranges correctly: when `adsCountIsRange` is true, `adsCount` is a lower bound.
6. Use `country` set to `ANY` when you want a global answer, and a specific code when you want a market answer.

### Call it from Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/ad-footprint-by-domain").call(run_input={
    "domains": ["hubspot.com", "notion.so", "basecamp.com"],
    "includeAdSamples": 0,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["domain"], row["footprintScore"], row["advertisingAnywhere"])
```

### More questions

**Does a score of 0 mean the company never advertised?** It means no ads were found in the libraries that answered, for the selected country. Check `sourceStatus` and `country`.

**Why do the Google and Meta counts differ so much?** They count different things: Google counts creatives for verified advertisers pointing at the domain, Meta counts active ads of matched Pages in one country.

**Can I check subdomains or landing pages?** Paste the URL in `startUrls`. The domain is taken from it.

**Does the actor show how much a company spends?** No. The libraries publish ads, formats and dates, not spend, so spend is not a field here.

**Can I compare more than 100 domains in one run?** Yes. Raise `maxItems` up to 5000.

**Why is LinkedIn not included?** LinkedIn's robots.txt forbids automated access, so each row has a library link and a status of `unavailable` instead.

**Is the data real time?** It is as current as the libraries at the time of the check. `checkedAt` records when that was.

**Can I send results to a spreadsheet or chat tool?** Yes, with an Apify integration on the dataset, or with the API calls above.

### FAQ

**Do I need API keys or logins?** No. The actor reads the same public pages a logged-out visitor sees.

**Why residential proxy?** Meta's Ad Library rate-limits datacenter IPs. Google is called directly and only falls back to the proxy if refused.

**Can I get every ad, not just a summary?** Use our Meta Ad Library scraper for full Meta ad rows. This actor is built for one fast summary row per company.

**What does the footprint score mean?** For each library that answered: 20 points for having ads, up to 15 for volume (log scale), 5 if an ad ran in the last 30 days; scaled to 0-100 over the libraries that answered.

**Something missing or broken?** Open an issue on the Issues tab with the run URL and we will reply there.

### Related actors

Pair this with other actors that take a domain as input:

- [Website Tech Stack Detector](https://apify.com/transparent_meteorite/website-tech-stack-detector) shows which marketing and analytics tools a site runs.
- [Company Enrichment by Domain](https://apify.com/transparent_meteorite/company-enrichment-by-domain) adds company details to the same domain list.
- [Domain Intelligence Lookup](https://apify.com/transparent_meteorite/domain-intelligence-lookup) returns registration and DNS facts for each domain.

### Legal note

The actor collects public ad transparency data published by Google and Meta about businesses' advertising. It does not log in, solve captchas or collect personal data about private individuals. You are responsible for using the data in line with each platform's terms and privacy laws such as GDPR.

### More from DWA Open Data

Browse all 69 data Actors, with live prices and sample output, at [open-data-actors.pages.dev](https://open-data-actors.pages.dev).

***

**Feedback:** if this Actor was useful, or if it fell short, an honest review on the [Reviews tab](https://apify.com/transparent_meteorite/ad-footprint-by-domain/reviews) helps other users decide. Problems or feature requests: please open an [Issue](https://apify.com/transparent_meteorite/ad-footprint-by-domain/issues) and we usually reply within one business day.

# Actor input Schema

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

Company domains to check, one per line (for example "hubspot.com"). Website URLs work too; the domain is taken from them.

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

Paste company website URLs (homepages, landing pages). Each URL's domain is checked once. Same as Domains, in the format other actors use.

## `brandNames` (type: `array`):

Override the brand keyword used to find the advertiser in the Meta Ad Library, in the same order as Domains (for example "Blue Bottle Coffee" for bluebottlecoffee.com). Leave empty to use the domain name.

## `sources` (type: `array`):

Which public ad libraries to check. LinkedIn is reported as unavailable (its robots.txt forbids automated access), with a link to check by hand.

## `country` (type: `string`):

Two-letter country code where the ads were shown (US, GB, DE, ...), or ANY for all countries.

## `includeAdSamples` (type: `integer`):

How many sample ads to attach per library (text, dates, preview link). The first 3 per library are included in the domain price; more cost the ad-sample event each.

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

Stop after this many domains.

## `onlyNew` (type: `boolean`):

Monitor mode: output (and charge) only domains whose ad counts or newest ads changed since the last run that used the same state store. The first run outputs everything.

## `stateStoreName` (type: `string`):

Named key-value store that remembers the last snapshot per domain for monitor mode. Use one name per watch list.

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

Meta rate-limits datacenter IPs, so residential Apify Proxy is the default. Google is called directly and falls back to this proxy.

## Actor input object example

```json
{
  "domains": [
    "hubspot.com",
    "notion.so"
  ],
  "startUrls": [],
  "sources": [
    "google",
    "meta",
    "linkedin"
  ],
  "country": "US",
  "includeAdSamples": 3,
  "maxItems": 100,
  "onlyNew": false,
  "stateStoreName": "ad-footprint-state",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `run` (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 = {
    "domains": [
        "hubspot.com",
        "notion.so"
    ],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/ad-footprint-by-domain").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 = {
    "domains": [
        "hubspot.com",
        "notion.so",
    ],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/ad-footprint-by-domain").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domains": [
    "hubspot.com",
    "notion.so"
  ],
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call transparent_meteorite/ad-footprint-by-domain --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/ad-footprint-by-domain"
        }
    }
}
```

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/zYVAgQCjL2J3BHe5u/builds/wwtcQcU4fx4WI79yF/openapi.json