# Bing Ads Library Scraper - Microsoft Ads Transparency (`scrapesage/bing-ads-library-scraper`) Actor

See every Bing ad any advertiser runs. Scrape the Microsoft Ad Library by keyword or advertiser: ad copy, landing pages, images, verified advertiser identity & new-ad monitoring. The Bing side of your Google/Meta ads transparency stack.

- **URL**: https://apify.com/scrapesage/bing-ads-library-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** SEO tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 ad scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Bing Ads Library Scraper — Competitor Ads, Advertisers & New-Ad Monitoring (Microsoft Advertising Transparency)

See **every ad any advertiser runs on Bing**. This actor scrapes the official **Microsoft Ad Library** — Microsoft Advertising's transparency register of ads served on Bing across the EU/EEA — and turns it into clean, structured competitor intelligence: **full ad copy (headlines + descriptions), display URLs, real landing-page URLs, image assets, verified advertiser identity, and per-advertiser ad counts**. Search by keyword, company name, advertiser ID, or library URL — and flip on **monitor mode** to get only the *new* ads a competitor launches between runs.

No login, no API key, no browser — fast JSON extraction straight from Microsoft's own library API, with 99%+ reliability.

### Why this Bing Ads Library scraper?

Google and Meta ad-spy tools are everywhere — but **Bing is the blind spot**: a ~$12B/yr ad platform with high-value insurance/finance/B2B/e-commerce advertisers and almost zero competitive-intel coverage. This actor closes that gap and ships the **richest dataset in the category**:

| Data | Typical scrapers | This actor |
|---|---|---|
| Full headline + ad copy | partial | ✅ complete |
| Real destination/landing URL + landing domain | ❌ | ✅ |
| Display URL (the path shown in the ad) | ✅ | ✅ |
| Image assets (URL + dimensions) for image formats | ❌ | ✅ |
| Advertiser registered country | ❌ | ✅ |
| Advertiser identity **verified** status | ❌ | ✅ |
| Per-advertiser total ads count + sample titles | ❌ | ✅ |
| All ads of one advertiser (by name **or** ID) | ❌ | ✅ |
| Advertiser register search (directory mode) | ❌ | ✅ |
| Country + date-range filters | ❌ | ✅ |
| Monitor mode — only new/changed ads per run | ❌ | ✅ |
| Deep links back to every ad & advertiser in the library | ❌ | ✅ |

### Use cases

- **Competitor PPC intelligence** — see every search ad a competitor runs on Bing, the exact copy angles they test, and the landing pages behind them. Bing CPCs run 30–60% below Google; the advertisers there are the ones quietly printing margin.
- **Ad copy research & swipe files** — harvest proven headlines/descriptions for any keyword ("car insurance", "crm software", "running shoes") to feed your own ad testing — or an LLM that writes variants.
- **New-ad alerts** — schedule a daily run with `monitorMode` on a competitor's advertiser ID and get only their newly launched ads, straight to Slack/CRM via integrations.
- **Lead generation** — advertiser-directory mode turns the library's register into a list of companies **actively spending on Bing ads** (name, country, verified identity, ad volume) — pre-qualified, budget-proven prospects for agencies and martech sales.
- **Landing-page & funnel analysis** — `destinationUrl` exposes the full tracking-parameter-laden final URL: see which pages, offers, and UTM structures competitors send paid traffic to.
- **Brand protection** — search your own brand name and find affiliates, resellers, or impostors bidding on it in any EU/EEA market.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Bing Ads Library Scraper**, enter keywords or advertiser names (or paste library URLs), and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "searchQueries": ["car insurance"],
    "advertiserNames": ["Booking.com"],
    "countries": ["DE", "France"],
    "dateFrom": "2026-01-01",
    "maxResults": 100,
    "includeAdvertiserDetails": true,
    "monitorMode": false
}
````

- **searchQueries** — keywords matched against ad copy; each returns up to ~1,000 ads.
- **advertiserNames** — company names, resolved in the advertiser register (up to 5 matches each), then **all their ads** are scraped.
- **advertiserIds** — exact advertiser IDs (the number in `adlibrary.ads.microsoft.com/advertiser/…` URLs).
- **advertiserSearchQueries** — search the **advertiser register** instead: one record per advertiser (country, verified, adsCount, sample titles). Directory mode for lead lists.
- **startUrls** — any Microsoft Ad Library URL (`/ad/…`, `/advertiser/…`, or `/?searchText=…`), auto-detected.
- **countries / dateFrom / dateTo** — server-side filters (EU/EEA countries, ISO codes or names; dates as YYYY-MM-DD).
- **adFormat** — `all`, `text` (classic search ads), or `image` (formats with image assets).
- **includeAdvertiserDetails** *(default true)* — adds registered country + verified status to every ad (one cached lookup per unique advertiser).
- **emitAdvertiserRecords** *(default false)* — also output one advertiser summary record per advertiser you scrape by name/ID.
- **maxResults** *(default 100)* — total record cap; `0` = no limit (explicit opt-in).
- **monitorMode / monitorStoreName** — cross-run new-ad detection (see below).

### Output

One record per ad (`type: "ad"`), plus optional advertiser records (`type: "advertiser"`):

```json
{
    "type": "ad",
    "adId": "71056166831708",
    "title": "Nike Dunk - Retrait en Magasin - Nike Dunk à partir de €39.99",
    "description": "Commande dès maintenant les Nike Dunk chez Foot Locker. Sois au-devant des tendances.",
    "displayUrl": "www.footlocker.fr/nike-dunk/foot-locker",
    "destinationUrl": "https://www.footlocker.fr/fr/category/chaussures.html?query=%3Arelevance%3Abrand%3ANike",
    "destinationDomain": "footlocker.fr",
    "displayDomain": "footlocker.fr",
    "adFormat": "text",
    "images": [],
    "imageCount": 0,
    "firstImageUrl": null,
    "advertiserId": "4295010202",
    "advertiserName": "Footlocker Europe.com B.V.",
    "advertiserCountry": "Netherlands",
    "advertiserVerified": true,
    "adLibraryUrl": "https://adlibrary.ads.microsoft.com/ad/71056166831708",
    "advertiserLibraryUrl": "https://adlibrary.ads.microsoft.com/advertiser/4295010202",
    "discoverySource": "q:nike",
    "filters": { "countries": null, "dateFrom": null, "dateTo": null },
    "queryTotalCount": 1000,
    "queryTotalIsCapped": true,
    "platform": "bing",
    "adLibrary": "Microsoft Ad Library (EU/EEA — DSA transparency)",
    "scrapedAt": "2026-07-02T09:00:00.000Z"
}
```

#### What to expect (field coverage)

- `title`, `description`, `displayUrl`, `destinationUrl`, `advertiserName`, `advertiserId`, library links — populated on ~100% of ads.
- `advertiserCountry`, `advertiserVerified` — populated whenever `includeAdvertiserDetails` is on (default).
- `images` / `firstImageUrl` — only for image-format ads; classic Bing search ads are text-only, so these are empty for most records (that's the source, not a scraping gap). Filter with `adFormat: "image"` if you only want creatives.
- `queryTotalCount` — the library reports at most 1,000 per query; `queryTotalIsCapped: true` means "1,000 or more".

### Monitor mode — only new ads, run after run

Set `monitorMode: true` and every scraped ad's fingerprint is remembered in a named key-value store. The next run outputs **only ads that are new or changed**, each tagged `monitorStatus: "new"` or `"updated"`. Pair it with an [Apify Schedule](https://docs.apify.com/platform/schedules) (they complement each other — the Schedule triggers runs, monitor mode dedupes the output):

1. Input: `{ "advertiserIds": ["4295010202"], "monitorMode": true, "maxResults": 0 }`
2. Schedule: daily.
3. Add a [webhook](https://docs.apify.com/platform/integrations/webhooks) or Zapier/Make step → new competitor ads land in Slack, email, or your CRM within a day of launch.

Running several monitors? Give each schedule its own `monitorStoreName`.

> **Tip:** monitor advertiser-scoped inputs (`advertiserIds` / `advertiserNames`) with `maxResults: 0` so the full ad set is compared every run. A broad keyword query capped at a fraction of its ~1,000 results samples a different slice each run — those ads aren't really "new", you just hadn't seen them yet.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — hourly/daily/weekly competitor sweeps.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/bing-ads-library-scraper').call({
    advertiserNames: ['Zalando'],
    countries: ['Germany'],
    maxResults: 500,
    monitorMode: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} Bing ads`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new competitor ads straight into your CRM or ad-ops board.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get pinged when a monitored advertiser launches new ads.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. You can call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "pull every Bing ad Zalando is running in Germany and summarize their copy angles" and let it run this scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **ads-transparency intelligence stack** — every major ad platform, one dataset shape:

- **[Google Ads Transparency Scraper](https://apify.com/scrapesage/google-ads-transparency-scraper)** — who's advertising what on Google.
- **[Facebook Ad Library Scraper](https://apify.com/scrapesage/facebook-ad-library-scraper)** — Meta + Instagram ads with monitoring mode.
- **[TikTok Ad Library Scraper](https://apify.com/scrapesage/tiktok-ad-library-scraper)** — TikTok top ads & creative intelligence.
- **[LinkedIn Ad Library Scraper](https://apify.com/scrapesage/linkedin-ad-library-scraper)** — competitor B2B ads & creatives.
- **[Keyword Research Scraper](https://apify.com/scrapesage/keyword-research-scraper)** — Google, YouTube, Amazon & Bing keyword data.
- **[Google Trends Scraper](https://apify.com/scrapesage/google-trends-scraper)** — interest, regions & rising queries.
- **[Website Tech Stack Scraper](https://apify.com/scrapesage/website-tech-stack-scraper)** — what competitors' sites run under the hood.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — turn advertiser domains into emails, phones & socials.

### Tips

- **Go deep on one advertiser**: the library caps any single query at ~1,000 ads. For mega-advertisers, split by `countries` and/or `dateFrom`/`dateTo` windows to pull far more.
- **Cheap daily monitors**: `advertiserIds` + `monitorMode` + a daily Schedule is the highest-signal, lowest-cost setup — you pay only for genuinely new ads.
- **Lead lists**: `advertiserSearchQueries: ["dentist"]` returns advertisers with "dentist" in their registered name — every one of them is actively buying Bing ads.
- **Keyword coverage**: searches match ad text, so try both brand ("nike") and category ("running shoes") terms — the ad sets differ.

### FAQ

**Where does the data come from?** From Microsoft's official **Microsoft Ad Library** (adlibrary.ads.microsoft.com), the transparency register Microsoft publishes under the EU Digital Services Act. This actor reads the same public API the library website uses — no login, no private data.

**Why EU/EEA only?** Microsoft's library publishes ads *served in the EU/EEA* — that's what the DSA mandates. Global brands (Nike, Booking.com, Amazon, insurance and SaaS advertisers…) all appear because they advertise in Europe; what you won't find is an ad shown *only* outside the EU/EEA.

**Does it include Microsoft Audience Network / image ads?** Yes — ads with image assets return `images` (URL + dimensions) and `adFormat: "image"`. Classic Bing search ads are text-only.

**Does it show ad spend or impressions?** Microsoft's library doesn't publish per-ad spend or impression counts (neither does Google's for non-political ads). You get the complete creative, targeting country availability via filters, advertiser identity, and ad volume per advertiser.

**How do I find an advertiser's ID?** Run their name through `advertiserNames` (the actor resolves it), use `advertiserSearchQueries` to list candidates, or copy the number from an `adlibrary.ads.microsoft.com/advertiser/…` URL.

**Can I monitor a competitor automatically?** Yes — that's the flagship use case. `monitorMode: true` + an Apify Schedule + a webhook = new-ad alerts. Monitor mode stores fingerprints in a key-value store and outputs only new/changed ads each run.

**Is scraping the Microsoft Ad Library legal?** The library is a public transparency register that exists precisely so ads can be inspected. The actor collects no personal data. You're responsible for complying with applicable laws and terms in your use of the data.

**A field is null — why?** Text ads genuinely have no images; advertisers you scrape without `includeAdvertiserDetails` won't carry country/verified. Fields are `null` only when the source doesn't expose the data, never because the scraper skipped it.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords or brand terms to search ads for (matches ad titles & copy) — e.g. "nike", "car insurance", "crm software". Each query returns up to ~1,000 ads.

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

Company/advertiser names — each is resolved in the library's advertiser register (up to 5 matching advertisers) and ALL of their ads are scraped. E.g. "Booking.com", "Zalando".

## `advertiserIds` (type: `array`):

Exact Microsoft Ad Library advertiser IDs (the number in adlibrary.ads.microsoft.com/advertiser/… URLs) — scrapes all their ads directly.

## `advertiserSearchQueries` (type: `array`):

Search the ADVERTISER register instead of ads — emits one advertiser record per match (name, country, verified status, ads count, sample ad titles). Great for building lists of companies actively advertising on Bing.

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

Microsoft Ad Library URLs — ad pages (…/ad/123), advertiser pages (…/advertiser/456), or search URLs (…/?searchText=shoes). Auto-detected and scraped.

## `countries` (type: `array`):

Only ads served in these countries. ISO codes or names — e.g. "DE", "France", "Netherlands". Empty = all EU/EEA countries.

## `dateFrom` (type: `string`):

Only ads served on/after this date (YYYY-MM-DD).

## `dateTo` (type: `string`):

Only ads served on/before this date (YYYY-MM-DD).

## `adFormat` (type: `string`):

Keep all ads, only classic text search ads, or only ads with image assets (audience/shopping formats).

## `includeAdvertiserDetails` (type: `boolean`):

Add the advertiser's registered country and identity-verification status to every ad (one cached lookup per unique advertiser).

## `includeAdvertiserAdStats` (type: `boolean`):

In advertiser-directory mode, probe each advertiser's ads to add adsCount + 3 sample ad titles (one extra request per advertiser).

## `emitAdvertiserRecords` (type: `boolean`):

When scraping by advertiser name/ID, additionally output one advertiser summary record (type: "advertiser") next to the ads.

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

Maximum records (ads + advertisers) to return. 0 = no limit (explicit opt-in; pair with a run timeout).

## `maxAdsPerQuery` (type: `integer`):

Per-query cap. 0 = no per-query cap (the library itself allows at most ~1,023 ads per query — use narrower queries or filters to go deeper).

## `monitorMode` (type: `boolean`):

Track ads across runs in a key-value store and only output ads that are new or changed since the last run — perfect on an Apify Schedule for competitor new-ad alerts. Works alongside (not instead of) Apify Schedules. Best with advertiser-scoped inputs and maxResults 0 (the full ad set is compared each run); broad keyword queries capped far below their ~1,000 results sample a different slice each run and will look 'new'.

## `monitorStoreName` (type: `string`):

Named key-value store holding monitor state (lowercase letters, digits, hyphens). Use a different name per schedule if you run several monitors.

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

The library API is an open Microsoft endpoint — default datacenter proxies work and are the cheapest. Switch to RESIDENTIAL only if you ever see blocked requests.

## Actor input object example

```json
{
  "searchQueries": [
    "nike"
  ],
  "adFormat": "all",
  "includeAdvertiserDetails": true,
  "includeAdvertiserAdStats": true,
  "emitAdvertiserRecords": false,
  "maxResults": 100,
  "maxAdsPerQuery": 0,
  "monitorMode": false,
  "monitorStoreName": "bing-ads-library-monitor",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped ad and advertiser records 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 = {
    "searchQueries": [
        "nike"
    ],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/bing-ads-library-scraper").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 = {
    "searchQueries": ["nike"],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/bing-ads-library-scraper").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 '{
  "searchQueries": [
    "nike"
  ],
  "maxResults": 100
}' |
apify call scrapesage/bing-ads-library-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bing Ads Library Scraper - Microsoft Ads Transparency",
        "description": "See every Bing ad any advertiser runs. Scrape the Microsoft Ad Library by keyword or advertiser: ad copy, landing pages, images, verified advertiser identity & new-ad monitoring. The Bing side of your Google/Meta ads transparency stack.",
        "version": "0.1",
        "x-build-id": "8bvMGihXlHT7J8qqZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~bing-ads-library-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-bing-ads-library-scraper",
                "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/scrapesage~bing-ads-library-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-bing-ads-library-scraper",
                "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/scrapesage~bing-ads-library-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-bing-ads-library-scraper",
                "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": {
                    "searchQueries": {
                        "title": "Search queries (keywords)",
                        "type": "array",
                        "description": "Keywords or brand terms to search ads for (matches ad titles & copy) — e.g. \"nike\", \"car insurance\", \"crm software\". Each query returns up to ~1,000 ads.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "advertiserNames": {
                        "title": "Advertiser names",
                        "type": "array",
                        "description": "Company/advertiser names — each is resolved in the library's advertiser register (up to 5 matching advertisers) and ALL of their ads are scraped. E.g. \"Booking.com\", \"Zalando\".",
                        "items": {
                            "type": "string"
                        }
                    },
                    "advertiserIds": {
                        "title": "Advertiser IDs",
                        "type": "array",
                        "description": "Exact Microsoft Ad Library advertiser IDs (the number in adlibrary.ads.microsoft.com/advertiser/… URLs) — scrapes all their ads directly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "advertiserSearchQueries": {
                        "title": "Advertiser directory search",
                        "type": "array",
                        "description": "Search the ADVERTISER register instead of ads — emits one advertiser record per match (name, country, verified status, ads count, sample ad titles). Great for building lists of companies actively advertising on Bing.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Microsoft Ad Library URLs — ad pages (…/ad/123), advertiser pages (…/advertiser/456), or search URLs (…/?searchText=shoes). Auto-detected and scraped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries (EU/EEA)",
                        "type": "array",
                        "description": "Only ads served in these countries. ISO codes or names — e.g. \"DE\", \"France\", \"Netherlands\". Empty = all EU/EEA countries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateFrom": {
                        "title": "Served from date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only ads served on/after this date (YYYY-MM-DD)."
                    },
                    "dateTo": {
                        "title": "Served to date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only ads served on/before this date (YYYY-MM-DD)."
                    },
                    "adFormat": {
                        "title": "Ad format",
                        "enum": [
                            "all",
                            "text",
                            "image"
                        ],
                        "type": "string",
                        "description": "Keep all ads, only classic text search ads, or only ads with image assets (audience/shopping formats).",
                        "default": "all"
                    },
                    "includeAdvertiserDetails": {
                        "title": "Enrich ads with advertiser details",
                        "type": "boolean",
                        "description": "Add the advertiser's registered country and identity-verification status to every ad (one cached lookup per unique advertiser).",
                        "default": true
                    },
                    "includeAdvertiserAdStats": {
                        "title": "Advertiser directory: include ad stats",
                        "type": "boolean",
                        "description": "In advertiser-directory mode, probe each advertiser's ads to add adsCount + 3 sample ad titles (one extra request per advertiser).",
                        "default": true
                    },
                    "emitAdvertiserRecords": {
                        "title": "Also emit advertiser records",
                        "type": "boolean",
                        "description": "When scraping by advertiser name/ID, additionally output one advertiser summary record (type: \"advertiser\") next to the ads.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results (total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum records (ads + advertisers) to return. 0 = no limit (explicit opt-in; pair with a run timeout).",
                        "default": 100
                    },
                    "maxAdsPerQuery": {
                        "title": "Max ads per query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per-query cap. 0 = no per-query cap (the library itself allows at most ~1,023 ads per query — use narrower queries or filters to go deeper).",
                        "default": 0
                    },
                    "monitorMode": {
                        "title": "Monitor mode (only new / changed ads)",
                        "type": "boolean",
                        "description": "Track ads across runs in a key-value store and only output ads that are new or changed since the last run — perfect on an Apify Schedule for competitor new-ad alerts. Works alongside (not instead of) Apify Schedules. Best with advertiser-scoped inputs and maxResults 0 (the full ad set is compared each run); broad keyword queries capped far below their ~1,000 results sample a different slice each run and will look 'new'.",
                        "default": false
                    },
                    "monitorStoreName": {
                        "title": "Monitor store name",
                        "type": "string",
                        "description": "Named key-value store holding monitor state (lowercase letters, digits, hyphens). Use a different name per schedule if you run several monitors.",
                        "default": "bing-ads-library-monitor"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "The library API is an open Microsoft endpoint — default datacenter proxies work and are the cheapest. Switch to RESIDENTIAL only if you ever see blocked requests.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
