# Ads Presence Unified Lookup: Google/LinkedIn/Meta from $16/1k (`accountable_eel/ads-presence-unified-lookup`) Actor

Is this company running ads anywhere? One domain or name in, one row out: Google Ads Transparency Center, LinkedIn Ad Library and Meta's Ad Library API checked at once. Never charged for a company with no ads on any checked platform.

- **URL**: https://apify.com/accountable\_eel/ads-presence-unified-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.16 / 1,000 ad presence checked (found on at least one platform)s

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

## Ads Presence Unified Lookup: Google, LinkedIn & Meta Ads for One Company

You give this actor a list of company domains or names. For each one, it checks the Google Ads
Transparency Center, the LinkedIn Ad Library, and Meta's official Ad Library API at once, and
returns a single row answering "is this company advertising, and where" — which platforms it's
active on, roughly how many ads, how recently, and a handful of sample ad URLs to click through
and verify by eye. It's a composite of this portfolio's own three single-platform actors
(`google-ads-presence-lookup`, `linkedin-ads-presence-lookup`, `meta-ads-presence-lookup`), fanned
out and billed as one flat charge per company instead of three separate ones.

### Who it's for

You're building or cleaning an outbound list and want one column that answers "is this prospect
already running paid ads anywhere" — a company that's actively buying ads on Google, LinkedIn or
Meta is a company with an ad budget and (usually) a marketing team already running campaigns,
which changes how you'd pitch a marketing, creative, or ad-tech tool to them. You're also useful
to a media buyer or competitive-intelligence analyst who wants a fast triage pass across a
competitor list before going deep on any one of them with the single-platform actors, and to an
agency doing prospecting who wants to filter out companies that already have an agency or in-house
team clearly running paid media. This isn't a bulk creative export — for that, see the three
single-platform actors below, each of which returns the full sample-ad detail for its one
platform. This is the fast, cheap "which of these 500 domains are worth a closer look" pass.

### Why this one

- **Three ad platforms, one row, one price.** Instead of running three actors and joining the
  results yourself, this fans out to all three ad libraries per company and folds them into one
  flat row — `anyAds`, `platformsActive`, and per-platform found/count fields — charged once, not
  three times. See "Price" below for exactly what "once" costs.
- **Never charged for a company that isn't advertising.** If none of the checked platforms show an
  ad, the row still comes back (`anyAds: false`) explaining why on each platform, and costs
  nothing.
- **Degrades gracefully instead of failing.** Meta's Ad Library API needs your own access token
  (see the FAQ) — without one, `metaAdsFound` comes back `false` with a plain-English reason, not
  an error, and Google and LinkedIn still run normally. Same for a rate limit or a blocked request
  on any platform: a per-platform miss never fails the row or the other two platforms.
- **Turn off any platform you don't need.** "Check Google Ads" / "Check LinkedIn Ads" / "Check Meta
  Ads" in the Input tab are on by default; turning one off skips it entirely for every row in the
  run — useful if you only have a Meta token, or only care about B2B (LinkedIn) presence.
- **Sample ad URLs to verify by eye.** Up to 3 URLs per active platform (Google Ads Transparency
  Center pages, LinkedIn Ad Library detail pages, Meta Ad Library snapshot URLs) so you're never
  taking the `true`/`false` on faith.

### What you get

One row per company. The three platform blocks are independent — a `null` on any found/count/
reason field means that platform wasn't checked this run (see the checkboxes above), not that it
returned zero.

| Field | Type | Description |
|---|---|---|
| `query` | text | The domain or company name you submitted |
| `found` | boolean | Same as `anyAds` below — `true` if at least one checked platform found ads. This is what's billed. |
| `status` | text | `OK` if any platform found ads; `NOT_FOUND` if none did |
| `message` | text | Plain-English summary of what each checked platform reported — only present when `found` is `false` |
| `advertiserName` | text | Best-matching advertiser/page name, from whichever platform matched first (Google, then LinkedIn, then Meta) |
| `googleAdsFound` | boolean/null | `true`/`false` if Google was checked; `null` if "Check Google Ads" was off |
| `googleAdsCount` | number/null | Estimated total ads in the Google Ads Transparency Center for the matched advertiser |
| `googleAdsLast30Days` | number/null | Estimated Google ads shown in the last 30 days |
| `googleAdsReason` | text/null | Why Google came back not-found or unchecked; `null` when found |
| `linkedinAdsFound` | boolean/null | `true`/`false` if LinkedIn was checked; `null` if "Check LinkedIn Ads" was off |
| `linkedinAdsCount` | number/null | Ads currently in the LinkedIn Ad Library for the matched advertiser |
| `linkedinAdsReason` | text/null | Why LinkedIn came back not-found or unchecked; `null` when found |
| `metaAdsFound` | boolean/null | `true`/`false` if Meta was checked; `null` if "Check Meta Ads" was off |
| `metaAdsCount` | number/null | Active Meta ads found, capped at 50 (Meta's own per-request sample size) |
| `metaAdsReason` | text/null | Why Meta came back not-found or unchecked — most commonly "no access token supplied" |
| `anyAds` | boolean | `true` if at least one checked platform found ads for this company |
| `platformsActive` | array | Which of `google`, `linkedin`, `meta` actually had ads (subset of what was checked) |
| `sampleAdUrls` | array | Up to 3 sample ad/library URLs per active platform, combined into one list |
| `scrapedAt` | ISO 8601 datetime | When the check ran |

Deselect any field in the Input tab's "Which columns do you want?" picker to drop it from every
row — this changes what's returned, not what's billed, since the price is flat per company either
way.

### Price

- **Ad presence checked (found on at least one platform)**: $16 per 1,000 company domains or names

Plus a $0.00005 start fee per run. Each event above is billed independently, only when it actually returns data — misses (`found:false`) are never charged.

1,000 companies through this actor: **~$16** if every one is found running ads somewhere
($0.016 per found row, plus a $0.00005 actor-start charge), less if some aren't. That's roughly
the sum of what the three single-platform actors would charge separately for the same company
(google-ads-presence-lookup $0.003, linkedin-ads-presence-lookup $0.012,
meta-ads-presence-lookup $0.003 — $0.018 combined) minus a 10% bundle discount for buying all
three at once, and it's a single flat charge regardless of how many of the three platforms
actually had ads — a company running ads on all three costs exactly the same as one running ads
on only one. A company with no ads on any checked platform is never billed at all.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `domains` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~ads-presence-unified-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"domains":["hubspot.com","notion.com","a-company-that-almost-certainly-runs-no-ads.example"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

4) If you have your own Meta Ad Library API access token, paste it into "Your Meta Ad Library API
   access token" at the top of the Input tab — without it, Meta is skipped gracefully on every row
   (see the FAQ).
5) Leave "Try it first" on for your first run to see the output shape on 5 companies before
   spending on the full list.
6) Turn off "Check Google Ads" / "Check LinkedIn Ads" / "Check Meta Ads" for any platform you
   don't need — this doesn't change the price of a found row, but it does mean one less request
   per company (faster, and one fewer thing that can come back `BLOCKED`).

### Input

```json
{
  "domains": [
    "hubspot.com",
    "notion.com",
    "a-company-that-almost-certainly-runs-no-ads.example"
  ]
}
```

One domain or company name per line. Each is checked against Google Ads Transparency Center, the LinkedIn Ad Library and Meta's Ad Library API, and comes back as one row. Accepted formats: nike.com, https://www.nike.com/gb/, Nike, Inc..

A bare domain works best for Google (which has a real domain filter); LinkedIn and Meta have no
domain filter at all, so a domain input is turned into a best-effort brand-name guess for those two
(stripping `www.` and the TLD — `"nike.com"` becomes the search term `"nike"`). A company name
("Nike, Inc.") works for all three and is generally more reliable for LinkedIn and Meta.

### Sample output

| query | found | status | advertiserName | googleAdsFound | googleAdsCount | googleAdsLast30Days | googleAdsReason | linkedinAdsFound | linkedinAdsCount | linkedinAdsReason | metaAdsFound | metaAdsCount | metaAdsReason | anyAds | platformsActive | sampleAdUrls | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| hubspot.com | true | OK | Hubspot, Inc. | true | 4000 | 2000 |  | true | 2568 |  | false |  | No Meta Ad Library API access token supplied — provide your own to check Meta. | true | \["google","linkedin"] | \["https://adstransparency.google.com/advertiser/AR10072600183532683265/creative/CR02771141177443876865?region=anywhere","https://adstransparency.google.com/advertiser/AR10072600183532683265/creativ... | 2026-09-21T06:10:16.874Z |

A company with no ads found on any checked platform gets a row with `found: false`, `anyAds:
false`, and a `message` summarizing what each platform reported — and is never charged.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~ads-presence-unified-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"domains":["hubspot.com","notion.com","a-company-that-almost-certainly-runs-no-ads.example"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~ads-presence-unified-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"domains":["hubspot.com","notion.com","a-company-that-almost-certainly-runs-no-ads.example"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~ads-presence-unified-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"domains":["{{company domain or name}}"]}`, mapping the row's company domain or name into the `domains` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Ad Library Checker: Google, Meta & LinkedIn by Domain" — the agent will find and run this actor.

Typical uses: adding an "already running ads?" column to a Clay prospect table before a marketing-
or ad-tech-tool outreach sequence, a weekly n8n workflow that re-checks a target-account list and
flags newly-active advertisers, or an AI agent qualifying a lead list by ad spend signal before
handing it to a sales rep.

### Tips

- Leave all three platforms on for the first pass over a new list — you can always narrow to one
  platform later once you know which one matters for your use case.
- If you only care about B2B accounts, "Check LinkedIn Ads" alone (with Google and Meta off) is
  the fastest and cheapest way to run this actor, since it skips the Google RPC and Meta API
  requests entirely.
- Without a Meta access token, `metaAdsFound` is always `null` (not checked) rather than `false` —
  that's expected, not a bug; see the FAQ for how to add one.
- `sampleAdUrls` links straight to each platform's own ad library page — worth a quick manual
  click-through before you act on a `true`, especially for a brand-name (not domain) input where
  the match is a best-effort text search rather than a verified identity.
- Domains match Google reliably; for LinkedIn and Meta, a company name ("Nike, Inc.") is more
  reliable than a bare domain, since neither has a real domain filter.

### vs. alternatives

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** (`ads-presence-unified-lookup`) | $0.016 per found row (~10% off the three single-platform prices combined), $0.00005 actor start, nothing for a miss | One row per company: Google, LinkedIn and Meta ad presence, counts, recency, and sample URLs, checked live on every run | Presence and rough volume, not a full creative export — for that, run the single-platform actor for the one you care about |
| `google-ads-presence-lookup` + `linkedin-ads-presence-lookup` + `meta-ads-presence-lookup` (this portfolio, run separately) | $0.003 + $0.012 + $0.003 = $0.018 per company found on all three, billed as three separate events | The same three platforms' full single-platform detail (image/text/video breakdown, verified/legal name, ad-type mix) — more depth per platform | Three actors to run and join yourself, and no bundle discount |
| **PowerAdSpy** (checked 2026-09) | $69–$399/month subscription, tiered by network | Facebook, Instagram, Google PPC and YouTube on every tier; **LinkedIn only unlocks on the $399/mo Palladium tier** | A real ad-creative library across many networks, but LinkedIn coverage costs 6x the entry price, and it's a seat-based monthly tool, not a pay-per-row API you can call from a workflow |
| Doing it yourself | Your time + reverse-engineering three different transports (Google's internal RPC, LinkedIn's Cloudflare-fronted HTML behind a residential-grade proxy requirement, Meta's official API auth flow), then joining three result sets per company | The same data | The per-platform quirks (LinkedIn needs Apify's UNBLOCKER proxy group specifically — see that actor's own notes — Google's RPC needs an undocumented client-context blob, Meta needs your own app token) are exactly what this actor absorbs |

Prices for third-party tools are their published list prices as of September 2026 and are not
tracked here — check the vendor before relying on the comparison.

### FAQ

**Do I need a Meta Ad Library API access token?**
Only if you want Meta results. Apply for one at
developers.facebook.com/docs/graph-api/reference/ads\_archive and paste it into the Input tab —
it's never shipped, stored, or logged by this actor, only sent as a request parameter on your own
runs. Without one, `metaAdsFound` comes back `null` for every row (not checked), and Google and
LinkedIn still run normally.

**Why is `metaAdsFound` false even outside the EU/UK when I know a company runs Facebook ads?**
Meta's official Ad Library API only covers ordinary commercial ads inside the EU/UK; everywhere
else, it's restricted to political and issue ads. This is Meta's own API restriction, not a bug
here — see meta-ads-presence-lookup's README for the full explanation. If you specifically need
Meta commercial-ad coverage outside the EU/UK, this actor can't provide it (no actor legitimately
can without violating Meta's terms).

**Am I charged for a company with no ads found?**
No. `found`/`anyAds` is `false` and the row explains why on each checked platform, and
`Actor.charge()` is never called for that row.

**What's the difference between `null` and `false` on `googleAdsFound` (or linkedin/meta)?**
`false` means that platform was checked and found nothing. `null` means that platform wasn't
checked this run at all — either because you turned its checkbox off, or (Meta only) because no
access token was supplied. Check the matching `...Reason` field for the specific explanation
either way.

**Does turning off a platform change the price?**
No — the price is one flat charge per company with `anyAds: true`, regardless of how many
platforms were checked or how many came back positive. Turning off a platform you don't need saves
time (fewer requests per company) and reduces what can come back `BLOCKED`, not money.

**Do I need to configure proxies?**
No. Google and LinkedIn each use a specific Apify proxy group internally (RESIDENTIAL and
UNBLOCKER respectively — LinkedIn requires UNBLOCKER specifically, see
linkedin-ads-presence-lookup's own notes on why), baked in and not buyer-configurable. Meta calls
its official API directly with no proxy at all.

**Is this a live check or a stored database?**
Live, on every run — there's no cached snapshot behind any of the three platforms. A company that
starts or stops running ads shows up differently the next time you check it.

**Should I use this instead of the three single-platform actors?**
Use this one for a fast "which of these companies are advertising anywhere" triage pass across a
list. Once you've narrowed to a handful of companies you want the full picture on — every sample
ad, image/text/video breakdown, verified advertiser identity — run the matching single-platform
actor(s) for the depth this one deliberately leaves out.

**Can I schedule this to re-check the same list on a cadence?**
Yes — set up an Apify Task with a schedule (daily, weekly, whatever cadence fits) and point it at
this actor with a saved input.

**Can an AI agent call this directly?**
Yes. It's registered on the Apify MCP server — an agent in Claude, Cursor, or another MCP client
can find and run it by name, or call the REST endpoint shown above from any script or workflow
tool.

### Related actors

- [Google Ads Presence Lookup](https://apify.com/accountable_eel/google-ads-presence-lookup) —
  the full single-platform Google Ads Transparency Center detail: image/text/video ad breakdown,
  verified advertiser identity, legal name, and monitoring mode.
- [LinkedIn Ads Presence Lookup](https://apify.com/accountable_eel/linkedin-ads-presence-lookup) —
  the full single-platform LinkedIn Ad Library detail, plus monitoring mode.
- [Meta Ads Presence Lookup](https://apify.com/accountable_eel/meta-ads-presence-lookup) — the
  full single-platform Meta Ad Library API detail, including EU reach data.
- [Company Domain Enrichment](https://apify.com/accountable_eel/company-domain-enrichment) —
  broader firmographic and technical enrichment (registration, DNS, tech stack, hiring signal) for
  the same domain.

# Actor input Schema

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

One domain or company name per line. Each is checked against Google Ads Transparency Center, the LinkedIn Ad Library and Meta's Ad Library API, and comes back as one row. Accepted formats: nike.com, https://www.nike.com/gb/, Nike, Inc.. You're only charged for the ones we actually find — a miss costs nothing.

## `metaAccessToken` (type: `string`):

Optional. Without it, Meta Ads is skipped gracefully for every row (reported as "not checked", never a failure) instead of erroring. Apply for your own token at developers.facebook.com/docs/graph-api/reference/ads\_archive — never shipped or shared by this actor.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

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

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `checkGoogleAds` (type: `boolean`):

Checks the Google Ads Transparency Center for each company. Turn off to skip Google entirely (cheaper, faster) if you only care about the other platforms.

## `checkLinkedinAds` (type: `boolean`):

Checks the LinkedIn Ad Library for each company. This is the platform most likely to need a retry under load — it's the only one of the three that requires Apify's UNBLOCKER proxy group to get past LinkedIn's bot defenses.

## `checkMetaAds` (type: `boolean`):

Checks Meta's official Ad Library API for each company — only useful if you've supplied your own access token above. Leave this on even without a token; it's a no-op cost-free skip either way.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

## Actor input object example

```json
{
  "domains": [
    "hubspot.com",
    "notion.com",
    "a-company-that-almost-certainly-runs-no-ads.example"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "checkGoogleAds": true,
  "checkLinkedinAds": true,
  "checkMetaAds": true,
  "columns": [
    "advertiserName",
    "googleAdsFound",
    "googleAdsCount",
    "googleAdsLast30Days",
    "googleAdsReason",
    "linkedinAdsFound",
    "linkedinAdsCount",
    "linkedinAdsReason",
    "metaAdsFound",
    "metaAdsCount",
    "metaAdsReason",
    "anyAds",
    "platformsActive",
    "sampleAdUrls"
  ],
  "maxConcurrency": 5
}
```

# 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 = {
    "domains": [
        "hubspot.com",
        "notion.com",
        "a-company-that-almost-certainly-runs-no-ads.example"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/ads-presence-unified-lookup").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "domains": [
        "hubspot.com",
        "notion.com",
        "a-company-that-almost-certainly-runs-no-ads.example",
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/ads-presence-unified-lookup").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "domains": [
    "hubspot.com",
    "notion.com",
    "a-company-that-almost-certainly-runs-no-ads.example"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/ads-presence-unified-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/ads-presence-unified-lookup"
        }
    }
}
```

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/DLIlbHaR7GElNic0O/builds/alQtX2HRfH5peSOCy/openapi.json