# Meta Ad Monitor (`deepmine/meta-ad-monitor`) Actor

Apify Meta Ads Library scraper that monitors competitor Facebook and Instagram ads in real time. Track new launches, killed creatives, proven winners, ad copy, CTA, links, and media by advertiser with automated change detection and scheduled reporting.

- **URL**: https://apify.com/deepmine/meta-ad-monitor.md
- **Developed by:** [DeepMine](https://apify.com/deepmine) (community)
- **Categories:** Social media, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$25.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#rental-actors

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Meta Ad Monitor — Track Competitor Ads Over Time

**See what your competitors changed in their Meta ads since last week. New launches, killed creatives, and proven winners — all in one scheduled run.**

Every other Meta Ads tool dumps the current state and stops there. This one runs on a schedule and tells you *what changed* — which ads are new tests, which got killed (didn't perform), and which have been running long enough to be confirmed winners.

***

### What It Does

Searches the Meta Ads Library for each advertiser you're monitoring, extracts their active ads, and compares against your previous run. The delta is the insight: new ads = what they're testing, killed ads = what didn't work, long-running ads = what's proven.

***

### The Delta Fields

| Field | What it means |
|---|---|
| `isNew` | This ad didn't exist in your last run — it just launched |
| `ageDelta` | How many more days this ad has been running since last check |
| `adAgeDays` | Total days this ad has been running |
| `trendLabel` | 🔥 Battle-tested (30+ days) / 📈 Gaining traction (14–30 days) / 🆕 New test (< 14 days) |

**First run:** establishes the baseline, delta fields will be null.
**Every run after:** shows exactly what changed.

***

### Output Tabs

#### Summary tab

One row per advertiser. Shows total active ads, new launches since last run, killed creatives, proven winner count, average ad age, and the longest-running ad's copy.

#### Ads tab

Every ad with full details. Sorted by age — proven winners (oldest) at the top. New ads flagged. Delta age shown for each ad.

***

### Output Fields

| Field | Description |
|---|---|
| `advertiser` | Advertiser name you searched for |
| `adArchiveId` | Meta's unique stable ID for this ad |
| `isActive` | Whether the ad is currently active |
| `isNew` | True if this ad wasn't in the previous run |
| `ageDelta` | Days added since last run (null on first run) |
| `adAgeDays` | Total days the ad has been running |
| `trendLabel` | Battle-tested / Gaining traction / New test |
| `body` | Ad copy text |
| `headline` | Ad headline |
| `cta` | Call-to-action button type (SHOP\_NOW, LEARN\_MORE, etc.) |
| `format` | Creative format (video, image, carousel) |
| `pageId` | Facebook page ID |
| `pageName` | Facebook page name |
| `imageUrl` | Ad image URL |
| `videoUrl` | Ad video URL |
| `linkUrl` | Destination URL |
| `startDate` | When the ad started running |
| `impressionsText` | Meta's impression range estimate |
| `spend` | Estimated spend data |

***

### Getting Started

1. Add one or more advertiser names (Facebook page names)
2. Enable **Track Changes** (on by default)
3. Schedule daily or weekly
4. Second run onward: see what changed

***

### Use Cases

**Media buyers and agencies**
Know what your clients' competitors are testing before your clients do. Track 5–10 competitor pages on a weekly cadence and surface the creative angles that are gaining traction.

**E-commerce brands**
See when a competitor launches a new product campaign, kills a promo that flopped, or scales a creative that's been running 60+ days. Stop guessing what's working in your market — look at the ads that survive.

**Marketing teams**
Monitor category leaders alongside your own page. Long-running ads from top brands are free market research for what hooks and CTAs your audience responds to.

***

### How Duration Signals Ad Performance

Meta advertisers stop running ads that don't perform — the cost is too high to sustain a losing creative. An ad that's been running for 30+ days has paid for itself enough times that the advertiser keeps spending on it. That's the signal.

- **< 14 days:** New test. Could go either way.
- **14–30 days:** Gaining traction. Probably working.
- **30+ days:** Battle-tested. This is what's working.

***

### Input Parameters

| Parameter | Default | Description |
|---|---|---|
| `advertiserNames` | Required | Facebook page names to monitor |
| `country` | `US` | Country to search ads for |
| `maxAdsPerAdvertiser` | `200` | Max ads to collect per advertiser |
| `trackChanges` | `true` | Enable delta tracking between runs |
| `proxyConfiguration` | Residential | Proxy settings |

***

### Related Actors

- **[Meta Ad Trend Finder](https://apify.com/your-username/meta-ad-trend-finder)** — find what hooks and formats are winning across a keyword or industry
- **[Meta Ad Spy](https://apify.com/your-username/meta-ad-spy)** — find winning dropshipping products by ad duration
- **[Meta Ad Intelligence](https://apify.com/your-username/meta-ad-intelligence)** — discover who's advertising in your market

***

*Data source: Meta Ads Library — a legally mandated public transparency database. No login required.*

# Actor input Schema

## `advertiserNames` (type: `array`):

Facebook page names or advertiser names to monitor. Add one per line. Each advertiser is tracked independently — the tool shows which ads are new, which got killed, and which have been running long enough to be proven winners.

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

Country to search ads for. Uses ISO 2-letter country code. US covers the most advertisers.

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

Maximum number of ads to collect per advertiser. 200 is enough for most monitoring use cases. Increase for advertisers with very large active ad libraries.

## `trackChanges` (type: `boolean`):

The core monitoring feature. Each run saves a snapshot. The next run compares against it and flags new ads, killed ads, and how many days each ad has added since last check.

Run on a schedule (daily or weekly) to continuously track competitor ad strategy. The first run establishes the baseline — delta fields will be null. From the second run onward, you see exactly what changed.

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

Proxy settings. Residential proxies are required — Meta's GraphQL pagination API rejects datacenter IPs. Only facebook.com API calls go through the proxy; CDN assets (JS bundles etc.) are fetched directly to minimise proxy bandwidth costs.

## Actor input object example

```json
{
  "advertiserNames": [
    "Nike",
    "Adidas"
  ],
  "country": "US",
  "maxAdsPerAdvertiser": 200,
  "trackChanges": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

## `ads` (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 = {
    "advertiserNames": [
        "Nike",
        "Adidas"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/meta-ad-monitor").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 = { "advertiserNames": [
        "Nike",
        "Adidas",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("deepmine/meta-ad-monitor").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 '{
  "advertiserNames": [
    "Nike",
    "Adidas"
  ]
}' |
apify call deepmine/meta-ad-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deepmine/meta-ad-monitor"
        }
    }
}

```

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/Z2qD3SkDCd2cZCYQT/builds/qMA2y5JrvWsEJuPvn/openapi.json