# Facebook Ads Library Scraper Pro (`sleeze22/facebook-ads-library-scraper-pro`) Actor

Scrape the public Facebook Ads Library by keyword or page. Flat, stable output. Streaming results, no null-surprise fields.

- **URL**: https://apify.com/sleeze22/facebook-ads-library-scraper-pro.md
- **Developed by:** [zSleezeh](https://apify.com/sleeze22) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## 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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Facebook Ads Library Scraper Pro

Scrape the public [Facebook Ads Library](https://www.facebook.com/ads/library/) by keyword or advertiser page. Get a **flat, predictable dataset** — no deeply nested objects, no fields that silently return `null`. Results **stream** to your dataset as they're found, so you see data immediately instead of waiting for the whole run.

Built for marketers, agencies, and competitive-intelligence teams who need clean ad data without fighting Facebook's changing internals.

### Why this scraper

- **Flat, stable schema** — one row per ad, the same fields every time. Drop it straight into a spreadsheet, database, or BI tool.
- **Streaming output** — ads appear in your dataset page by page, not all at the end.
- **Handles multi-card ads** — pulls the real creative (text, link, CTA, media) from carousel/multi-card ads, where many scrapers return empty fields.
- **Self-healing** — automatically adapts to Facebook's rotating internal query IDs, so it keeps working when other scrapers break.
- **Transparent price** — **$3.00 / 1,000 ads**, cheaper than the main alternative on the Store.

### What you can do with it

- Spy on competitors' active ad creative, copy, and landing pages
- Track how long ads run and which platforms they target (Facebook, Instagram, Messenger, Audience Network, Threads)
- Build ad-inspiration libraries and swipe files
- Monitor a brand's ad activity over time by page
- Feed ad data into your own dashboards or AI pipelines

### Input

Provide **one** of:

- `searchTerms` — keywords, e.g. `["nike", "running shoes"]`
- `pageIds` — Facebook page IDs to pull all ads from a specific advertiser
- `pageUrls` — Facebook page URLs (numeric-ID URLs supported)

Then optionally filter:

| Field | Values | Default |
|---|---|---|
| `country` | ISO code (e.g. `US`) or `ALL` | `ALL` |
| `activeStatus` | `active`, `inactive`, `all` | `active` |
| `mediaType` | `all`, `image`, `video` | `all` |
| `maxResults` | any integer | `100` |

#### Example input

```json
{
  "searchTerms": ["nike"],
  "country": "US",
  "activeStatus": "active",
  "mediaType": "all",
  "maxResults": 100
}
````

### Output

One item per ad:

`adArchiveId`, `pageId`, `pageName`, `pageProfileUrl`, `pageLikes`, `adText`, `ctaText`, `ctaType`, `linkUrl`, `mediaType`, `imageUrls[]`, `videoUrls[]`, `platforms[]`, `startDate`, `endDate`, `isActive`, `spend`, `impressions`, `collationCount`.

#### Example output

```json
{
  "adArchiveId": "1177031937640804",
  "pageName": "Amazon Fashion",
  "pageProfileUrl": "https://www.facebook.com/AmazonFashion/",
  "pageLikes": 4234608,
  "adText": "Shop Adidas on Amazon.",
  "ctaText": "Shop Now",
  "ctaType": "SHOP_NOW",
  "linkUrl": "https://www.amazon.com/dp/B0D28FDLKF",
  "mediaType": "image",
  "imageUrls": ["https://.../card1.jpg"],
  "platforms": ["FACEBOOK", "INSTAGRAM"],
  "isActive": true,
  "startDate": "2024-07-01"
}
```

### Pricing

**$3.00 per 1,000 ads**, pay per result — you only pay for ads actually returned. Cheaper than the main alternative on the Store, with results that stream instead of appearing only at the end.

### FAQ

**Do I need a Facebook login or cookies?** No. Data comes from Meta's public Ads Library transparency tool.

**Why did a run return zero results?** Meta occasionally rotates its internal endpoints. The scraper self-heals on most changes; if a run still comes back empty, open an issue and it'll be fixed quickly.

**Can I get all ads from one advertiser?** Yes — pass their `pageIds` (or a numeric-ID `pageUrls`) and set `activeStatus` to `all`.

**Is scraping the Ads Library allowed?** The Ads Library is Meta's public ad-transparency tool. This actor only reads publicly visible data.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search ads for.

## `pageUrls` (type: `array`):

Facebook page URLs to scrape ads from.

## `pageIds` (type: `array`):

Facebook page IDs to scrape ads from.

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

ISO country code or ALL.

## `activeStatus` (type: `string`):

Filter by whether ads are currently running.

## `mediaType` (type: `string`):

Filter ads by creative media type.

## `maxResults` (type: `integer`):

Maximum number of ads to return.

## Actor input object example

```json
{
  "searchTerms": [
    "nike"
  ],
  "country": "ALL",
  "activeStatus": "active",
  "mediaType": "all",
  "maxResults": 100
}
```

# 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 = {
    "searchTerms": [
        "nike"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sleeze22/facebook-ads-library-scraper-pro").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 = { "searchTerms": ["nike"] }

# Run the Actor and wait for it to finish
run = client.actor("sleeze22/facebook-ads-library-scraper-pro").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "nike"
  ]
}' |
apify call sleeze22/facebook-ads-library-scraper-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sleeze22/facebook-ads-library-scraper-pro",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Ads Library Scraper Pro",
        "description": "Scrape the public Facebook Ads Library by keyword or page. Flat, stable output. Streaming results, no null-surprise fields.",
        "version": "0.1",
        "x-build-id": "0PZF4TZQ3vSh2qsM0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sleeze22~facebook-ads-library-scraper-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sleeze22-facebook-ads-library-scraper-pro",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/sleeze22~facebook-ads-library-scraper-pro/runs": {
            "post": {
                "operationId": "runs-sync-sleeze22-facebook-ads-library-scraper-pro",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/sleeze22~facebook-ads-library-scraper-pro/run-sync": {
            "post": {
                "operationId": "run-sync-sleeze22-facebook-ads-library-scraper-pro",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search ads for.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "pageUrls": {
                        "title": "Page URLs",
                        "type": "array",
                        "description": "Facebook page URLs to scrape ads from.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "pageIds": {
                        "title": "Page IDs",
                        "type": "array",
                        "description": "Facebook page IDs to scrape ads from.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "ISO country code or ALL.",
                        "default": "ALL"
                    },
                    "activeStatus": {
                        "title": "Active status",
                        "enum": [
                            "active",
                            "inactive",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter by whether ads are currently running.",
                        "default": "active"
                    },
                    "mediaType": {
                        "title": "Media type",
                        "enum": [
                            "all",
                            "image",
                            "video"
                        ],
                        "type": "string",
                        "description": "Filter ads by creative media type.",
                        "default": "all"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of ads to return.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
