# LinkedIn Ad Library Scraper — Ads, Targeting & Reach | $1.75/1k (`glasswing/linkedin-ad-library-scraper`) Actor

Scrape the public LinkedIn Ad Library without an account: company advertiser, ad format, ad text, headline and creative, plus optional details: company page, CTA, landing URL, first/last shown dates, impressions by country and targeting. Search by keyword, advertiser, country and date.

- **URL**: https://apify.com/glasswing/linkedin-ad-library-scraper.md
- **Developed by:** [Raffy](https://apify.com/glasswing) (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.40 / 1,000 ads

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

### What does LinkedIn Ad Library Scraper do?

Get the ads companies run on LinkedIn as clean spreadsheet rows. The fast **basic row** comes straight from the search results: ad id, advertiser, ad format, ad text, headline, image or video poster and carousel cards. Switch on **Include ad details** and every ad also gets its advertiser's company page, the "Paid for by" entity, ad format (single image, video, carousel, document, text...), the full ad copy, headline, call-to-action button, landing URL, image and video links, the first and last day the ad was shown, the impressions range with the share per country, and the targeting the advertiser chose (language, locations, and which audience, company, job, education and demographic criteria were used).

Search the **LinkedIn Ad Library** by keyword, by advertiser (company) name or by payer, narrow it by country and date range, or paste Ad Library URLs and ad ids, and **scrape LinkedIn ads** into JSON, CSV or Excel, or read them from the Apify API. It works as a practical **LinkedIn Ad Library API** for marketers, agencies, analysts and AI agents: no LinkedIn account, no login, no cookies, nothing to install.

It reads only the **public LinkedIn Ad Library**, the pages LinkedIn shows to anyone who is not signed in. Only ads run by **company pages** are returned. Ads posted by individual members (including "thought-leader" ads, where a company promotes an employee's post) are skipped and never saved, so no member names, headlines, photos or profile links ever reach your dataset.

**$1.75 per 1,000 ads** (basic rows), **$2.95 per 1,000 with details**, plus $0.005 per run. Platform compute and residential proxy included.

### Use cases for this LinkedIn ads scraper

- **Competitor ad monitoring.** Enter a competitor's name in **Advertiser** and schedule a weekly run: see every new creative, its CTA, landing page and how long it ran (`firstShown`, `lastShown`).
- **Creative research and swipe files.** Collect `adText`, `headline`, `callToAction` and `imageUrl`/`videoUrl` for a keyword like `cybersecurity` or `payroll` and see which hooks and formats B2B advertisers use.
- **Targeting insights.** `targetingLocationsIncluded`, `targetingLanguage` and `targetingParameters` show where and how a company aims its LinkedIn budget; `impressionsByCountry` shows where the ads were actually seen.
- **Lead generation for agencies.** Companies advertising on LinkedIn have a B2B marketing budget. Search your niche, group rows by `advertiserName` and `advertiserUrl`, and build a prospect list of active advertisers.
- **Market and campaign research.** Track how many ads a category runs per month with the date range filter, and which landing pages (`landingUrl`) they send traffic to.
- **AI agents and automations.** Call it with `{"advertiser": "HubSpot", "maxItems": 50}` from an MCP client, n8n, Make or Zapier and get structured rows back.

### What data can LinkedIn Ad Library Scraper extract?

One row per ad. Fields marked **D** are filled only with **Include ad details** on (or when you give ad URLs/ids); `detailsIncluded` tells you which kind of row you have. The **Overview** table shows `advertiserName`, `adFormat`, `adText`, `callToAction`, `landingUrl`, `firstShown`, `lastShown`, `impressionsRange`, `advertiserUrl`, `url`, `status` and `error`.

**Ad and advertiser**

| Field | Type | Description |
|---|---|---|
| `adId` | string | LinkedIn's numeric ad id, e.g. `1601068074`. |
| `url` | string | The ad's Ad Library page, `https://www.linkedin.com/ad-library/detail/<adId>`. |
| `advertiserName` | string | Company page that ran the ad. |
| `advertiserUrl` | string | **D** The company's LinkedIn page. |
| `advertiserCompanyId` | string | **D** Numeric LinkedIn company id. |
| `advertiserLogoUrl` | string | Company logo image URL. |
| `paidBy` | string | **D** The entity in the "Paid for by" line. |

**Creative**

| Field | Type | Description |
|---|---|---|
| `adFormat` | string | `Single Image Ad`, `Video Ad`, `Carousel Ad`, `Document Ad`, `Text Ad`, `Event Ad`, ... |
| `creativeType` | string | LinkedIn's internal code, e.g. `SPONSORED_STATUS_UPDATE`, `SPONSORED_VIDEO`, `SPONSORED_UPDATE_CAROUSEL`. |
| `adText` | string | Ad copy (introductory text), line breaks kept. Basic rows carry LinkedIn's preview, which is cut after about 150 characters (ends with `…`); with details it is the full text. |
| `headline` | string | Headline under the image or video. |
| `callToAction` | string | **D** Button text, e.g. `Learn more`, `Download`, `Sign Up`, `Register`. |
| `landingUrl` | string | **D** Where the ad sends people (LinkedIn's own tracking parameter removed). Empty for ads without a link, e.g. lead-gen form ads. |
| `imageUrl` | string | Main image, or the poster frame of a video. |
| `videoUrl` | string | **D** Highest-quality MP4 of a video ad. |
| `carouselCards` | array | Carousel cards: `title`, `imageUrl`, and with details `landingUrl`. |
| `detailsIncluded` | boolean | `true` when the row was built from the ad's detail page (billed with the extra `Ad details` event), `false` for a basic row. |

**Dates, reach and targeting**

| Field | Type | Description |
|---|---|---|
| `firstShown` | string | **D** First day the ad was shown, `YYYY-MM-DD`. |
| `lastShown` | string | **D** Last day the ad was shown, `YYYY-MM-DD`. |
| `impressionsRange` | string | **D** Total impressions as LinkedIn reports them, e.g. `< 1k`, `1k-5k`, `100k-250k`. |
| `impressionsByCountry` | array | **D** Share of impressions per country: `country`, `share` (e.g. `28%`). |
| `targetingLanguage` | string | **D** Targeted language(s). |
| `targetingLocationsIncluded` | array | **D** Targeted countries, regions and cities. |
| `targetingLocationsExcluded` | array | **D** Excluded locations. |
| `targetingParameters` | array | **D** Each targeting category (`Audience`, `Demographic`, `Company`, `Education`, `Job`, `Member Interests and Traits`) with `targeted` and `excluded` flags. |

LinkedIn publishes dates, impressions and targeting for ads that were shown in the EU (Digital Services Act transparency). For ads shown only outside the EU those fields are empty.

**Row status**

| Field | Type | Description |
|---|---|---|
| `status` | string | `ok`, `not_found` or `error` (below). |
| `error` | string | Reason when `status` is not `ok`. |
| `scrapedAt` | string | ISO 8601 time the row was written. |

| `status` | Meaning | Billed? |
|---|---|---|
| `ok` | An ad run by a company page. | Yes |
| `not_found` | LinkedIn answered, but there is nothing to return: an unknown ad id, a search with no ads, or an ad posted by an individual member (skipped for privacy). | No |
| `error` | LinkedIn could not be read after retries. `error` says why. | No |

### How to scrape the LinkedIn Ad Library

1. Open the Actor and click **Try for free**.
2. Type a **Keyword** and/or an **Advertiser (company) name** - or paste LinkedIn Ad Library URLs or ad ids into **Ad Library URLs or ad ids**.
3. Optional: add **Countries** (two-letter codes such as `US`, `DE`, `GB`) and a **Date range** (last 30 days, current month, current or last year, or your own start and end date).
4. Set **Maximum results** (the default 20 shows you the output in about a minute).
5. Click **Start**, then open the **Output** tab or export the dataset as JSON, CSV, Excel, XML or HTML.

To automate it, use the **API** tab (Node.js, Python, curl) or add a **Schedule**.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `query` | string | - | Keyword or phrase from the ad copy, e.g. `cybersecurity`. |
| `advertiser` | string | - | Company/advertiser name, e.g. `Microsoft`. Works alone or with a keyword. |
| `payer` | string | - | The "Paid for by" entity. |
| `countries` | array of strings | all | ISO two-letter codes of the countries where the ads were shown. |
| `dateRange` | string | all | `last-30-days`, `current-month`, `current-year`, `last-year` or `custom-date-range`. |
| `startDate` / `endDate` | string | - | `YYYY-MM-DD` for a custom range (LinkedIn keeps the last 12 months). |
| `startUrls` | array of strings | one example search | Ad Library search URLs (all filters kept), ad URLs or bare ad ids. The example is skipped as soon as you fill in Keyword, Advertiser or Paid for by. |
| `maxItems` | integer | `20` | Stop after this many ads. |
| `includeDetails` | boolean | `false` | Open every ad's detail page for the **D** fields (company page, landing URL, CTA, full text, dates, impressions, targeting). Billed as an extra `Ad details` event per ad. |
| `datacenterProxy` | boolean | `false` | Use Apify's datacenter proxy instead of residential. LinkedIn blocks most datacenter IPs on the Ad Library; leave it off. |
| `proxyConfiguration` | object | Apify Proxy, RESIDENTIAL | Residential proxy, included in the price. Leave the proxy country empty: the Actor picks the exit countries LinkedIn serves best (the ads you get depend on **Countries**, not on the proxy). |

Example input:

```json
{
    "advertiser": "HubSpot",
    "countries": ["US", "GB"],
    "dateRange": "last-30-days",
    "maxItems": 200,
    "includeDetails": true
}
```

### Output

A basic row (default, from the search results):

```json
{
    "url": "https://www.linkedin.com/ad-library/detail/1648309166",
    "status": "ok",
    "adId": "1648309166",
    "advertiserName": "Ronin Advisory",
    "adFormat": "Video Ad",
    "advertiserLogoUrl": "https://media.licdn.com/dms/image/v2/D560BAQGOcZYU-wShwA/company-logo_100_100/...",
    "creativeType": "SPONSORED_VIDEO",
    "adText": "We took AI for a spin. Things escalated quickly. ...",
    "headline": "The Chase Is Fictional. The Strategy Is Real.",
    "imageUrl": "https://media.licdn.com/dms/image/v2/D5610AQFLKgWOj7niZQ/videocover-high/...",
    "detailsIncluded": false,
    "scrapedAt": "2026-10-19T09:53:54.568Z"
}
```

A row with **Include ad details** on (ad text shortened):

```json
{
    "url": "https://www.linkedin.com/ad-library/detail/1601068074",
    "status": "ok",
    "adId": "1601068074",
    "advertiserName": "Quantum Security Defence",
    "advertiserUrl": "https://www.linkedin.com/company/101691424",
    "advertiserCompanyId": "101691424",
    "paidBy": "Quantum Security and Defense Working Group lts",
    "adFormat": "Video Ad",
    "creativeType": "SPONSORED_VIDEO",
    "adText": "You don't need to be a physicist to understand why quantum technology matters. ...",
    "headline": "Quantum Business Bootcamp For Executives",
    "callToAction": "Learn more",
    "landingUrl": "https://quantumsecuritydefence.com/business-bootcamp/",
    "imageUrl": "https://media.licdn.com/dms/image/v2/D4E10AQF15zCAsTRFng/videocover-high/...",
    "videoUrl": "https://dms.licdn.com/playlist/vid/v2/D4E10AQF15zCAsTRFng/progressive-servable-video/...",
    "firstShown": "2026-10-17",
    "lastShown": "2026-10-18",
    "impressionsRange": "< 1k",
    "targetingLanguage": "English",
    "targetingLocationsIncluded": ["Ireland", "United Kingdom"],
    "targetingParameters": [
        { "parameter": "Audience", "targeted": false, "excluded": false },
        { "parameter": "Company", "targeted": true, "excluded": false },
        { "parameter": "Job", "targeted": true, "excluded": false }
    ],
    "detailsIncluded": true,
    "scrapedAt": "2026-10-19T08:49:17.920Z"
}
```

An ad posted by an individual member is never returned. Basic rows simply skip it; when a detail page reveals one, its row is free and carries no member data:

```json
{
    "url": "https://www.linkedin.com/ad-library/detail/1595579694",
    "status": "not_found",
    "error": "Ad posted by an individual LinkedIn member (member or thought-leader ad), not by a company page; skipped for privacy.",
    "scrapedAt": "2026-10-19T08:47:21.862Z"
}
```

### How much does it cost to scrape LinkedIn ads?

Pay per event, platform compute and residential proxy included:

| Event | Price |
|---|---|
| Actor start | $0.005 per run |
| Ad (`status: ok` company ad) | $0.00175 per ad ($1.75 per 1,000) |
| Ad details (extra, only rows with `detailsIncluded: true`) | $0.0012 per ad ($1.20 per 1,000) |

Examples: the default 20-ad run costs $0.04; 1,000 basic ads cost $1.755; 1,000 ads with details $2.955; 10,000 ads with details $29.505. Ad URLs or ids you paste are always read from the detail page, so they bill both events. Rows with status `not_found` or `error` are never billed. Cap spending with **Maximum results** and the run's **Max total charge**; the Actor stops cleanly when either is reached.

### Speed and reliability

LinkedIn answers requests from most server and many residential IP addresses with "blocked". The Actor uses Apify's residential proxy, checks every proxy session with one tiny request before using it, and prefers the exit countries LinkedIn currently serves best, so blocked addresses never cost you rows. A session that gets blocked or throttled later is dropped and the request is retried at once on the next checked session. Basic rows come 24 ads per search page, at about 200 ads per minute (500 ads in about 2.5 minutes); with details expect about 60 ads per minute. The default 20-ad run takes well under a minute.

### Tips

- One search shows ads in LinkedIn's order (newest first). For large advertisers, split by **Countries** or **Date range** to get more distinct ads.
- Keyword searches for broad words (`leadership`, `career`) return many member posts, which are skipped; an **Advertiser** search or a business keyword gives more company ads per page.
- Paste a search URL from the Ad Library in your browser to keep exactly the filters you set there.

### Limitations

- Only ads by company pages are returned; member and thought-leader ads are skipped by design.
- Dates, impressions and targeting exist only for ads LinkedIn reports under EU transparency rules (ads shown in the EU); other ads have the creative and advertiser fields only.
- LinkedIn keeps about 12 months of ads; custom date ranges outside that return nothing.
- Impressions are ranges (e.g. `1k-5k`), not exact numbers; spend is not published by LinkedIn.
- Ads without a destination link (lead-gen forms, some video ads) have no `landingUrl`.
- The run needs Apify Proxy: residential is on by default and included in the price.
- Basic rows include only ads whose advertiser shows a company logo; a company without a logo appears only with **Include ad details** on.

### FAQ

**Do I need a LinkedIn account or cookies?** No. The Actor reads the public LinkedIn Ad Library without logging in.

**Is it legal to scrape the LinkedIn Ad Library?** The Ad Library is a public transparency tool, and the Actor collects only ads run by companies, no member data. You are responsible for how you use the data; read the notice below and LinkedIn's terms.

**Basic rows or details?** Basic rows answer "who advertises what": advertiser, format, text preview, headline, creative. Turn on details when you need landing pages, CTAs, run dates, impressions or targeting.

**Why did I get fewer rows than Maximum results?** The search had fewer company ads, some results were member ads (skipped, free), or the run's charge limit was reached. The run log says which.

**Can I get the ad spend?** No. LinkedIn does not publish spend, only impression ranges.

**Can an AI agent call it?** Yes. With no input at all it returns 20 recent `cybersecurity` ads. Agents can pass `query`, `advertiser`, `countries` and `dateRange` as plain values, and every row says whether it is data (`ok`), an empty answer (`not_found`) or a failure (`error`).

**How fresh is the data?** Every run reads LinkedIn live; nothing is cached.

### Related Actors

- [Google Ads Transparency Scraper](https://apify.com/glasswing/google-ads-transparency-scraper) - use it to see the same advertisers' Google Search, YouTube and Display ads.
- [LinkedIn Company Scraper](https://apify.com/glasswing/linkedin-company-scraper) - use it to add website, industry, size and headquarters for the companies behind the ads.
- [LinkedIn Jobs Scraper](https://apify.com/glasswing/linkedin-jobs-scraper) - use it to see which advertisers are also hiring, and for which roles.
- [Domain Intelligence Report](https://apify.com/glasswing/domain-intelligence-report) - use it to profile the landing-page domains the ads send traffic to.
- [Keyword Suggestions Scraper](https://apify.com/glasswing/keyword-suggestions-scraper) - use it to expand ad keywords into the search terms buyers type.
- [Google Trends Scraper](https://apify.com/glasswing/google-trends-scraper) - use it to check demand for the topics competitors advertise.

### Legal and data-protection notice

This Actor extracts only ads that LinkedIn publishes in its public Ad Library to visitors who are not signed in. It does not log in, does not solve challenges, and does not extract member data: ads posted by individual members are skipped, and no names, headlines, photos or profile links of members are returned. Ad copy is written by advertisers and can still mention a person; personal data is protected by the GDPR in the European Union and by other laws worldwide, so do not use such data without a legitimate reason. You are responsible for complying with LinkedIn's terms of service and applicable law when you use the extracted data.

This Actor is an independent tool. It is not affiliated with, endorsed by or sponsored by LinkedIn Corporation. LinkedIn is a trademark of LinkedIn Corporation; all trademarks belong to their respective owners.

# Changelog

This Actor's version history is a separate document: https://apify.com/glasswing/linkedin-ad-library-scraper/changelog.md

# Actor input Schema

## `query` (type: `string`):

A word or phrase from the ad copy, e.g. `cybersecurity` or `free trial`. Combine it with the filters below.

## `advertiser` (type: `string`):

Company or advertiser name as LinkedIn shows it, e.g. `Microsoft` or `HubSpot`. Works alone or together with a keyword.

## `payer` (type: `string`):

Optional: the legal entity that paid for the ads (the "Paid for by" line).

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

Optional: two-letter country codes where the ads were shown, e.g. `US`, `DE`, `GB`. Leave empty for all countries.

## `dateRange` (type: `string`):

Optional: when the ads ran. LinkedIn keeps the last 12 months. For your own dates pick `Custom` and fill in Start and End date.

## `startDate` (type: `string`):

Optional, `YYYY-MM-DD`: ads shown on or after this day (custom date range).

## `endDate` (type: `string`):

Optional, `YYYY-MM-DD`: ads shown on or before this day (custom date range).

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

LinkedIn Ad Library search URLs (copied from your browser), ad detail URLs like `https://www.linkedin.com/ad-library/detail/1584697093`, or bare ad ids. The example is skipped automatically when you fill in Keyword, Advertiser or Paid for by.

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

Stop after this many ads have been saved. Each saved company ad with status `ok` is one billable `Ad` event (plus `Ad details` when details are included).

## `includeDetails` (type: `boolean`):

Open every ad's detail page for the advertiser's company page URL, landing URL, call to action, full ad text, paid-by, first/last shown dates, impressions by country and targeting. Billed as an extra `Ad details` event per ad. Off: the fast basic row from the search results (ad id, advertiser, format, ad text preview, headline, image/video).

## `datacenterProxy` (type: `boolean`):

Off by default. LinkedIn blocks most datacenter IPs on the Ad Library, so leave this off unless you know your datacenter proxy is served.

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

Apify Proxy RESIDENTIAL is the default (included in the price): LinkedIn blocks most server and many residential IPs on the Ad Library, so the Actor checks every proxy session with one tiny request and only uses sessions LinkedIn serves, preferring the exit countries that work best. Leave the country empty; the ads you get do not depend on the proxy country (use Countries above for that).

## Actor input object example

```json
{
  "startUrls": [
    "https://www.linkedin.com/ad-library/search?keyword=cybersecurity"
  ],
  "maxItems": 20,
  "includeDetails": false,
  "datacenterProxy": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "startUrls": [
        "https://www.linkedin.com/ad-library/search?keyword=cybersecurity"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("glasswing/linkedin-ad-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 = {
    "startUrls": ["https://www.linkedin.com/ad-library/search?keyword=cybersecurity"],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("glasswing/linkedin-ad-library-scraper").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 '{
  "startUrls": [
    "https://www.linkedin.com/ad-library/search?keyword=cybersecurity"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call glasswing/linkedin-ad-library-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,glasswing/linkedin-ad-library-scraper"
        }
    }
}
```

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/2WJGjRETmlajTSgFI/builds/2EFrU9HSr9dG6PcXA/openapi.json