# Amazon Ad Library Scraper - EU Ads & Impressions (`automation_craft/amazon-ad-library-scraper`) Actor

Scrape the Amazon Ad Library, the public EU ad repository of amazon.de and eight more stores, by keyword, advertiser or ad id. One row per distinct ad, charged once: advertiser, payer, product title and ASIN, days shown, impressions per country, targeting, removed ads. JSON, CSV, API.

- **URL**: https://apify.com/automation_craft/amazon-ad-library-scraper.md
- **Developed by:** [Automation Craft](https://apify.com/automation_craft) (community)
- **Categories:** Marketing, E-commerce, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.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

### Amazon Ad Library Scraper - EU Ads & Impressions

Scrape the **Amazon Ad Library**, the public ad repository of Amazon's nine EU stores (amazon.de, amazon.fr, amazon.it, amazon.es, amazon.nl, amazon.pl, amazon.se, amazon.com.be and amazon.ie, about 1.3 billion ads), by keyword, by advertiser name, by ad id, or through the removed ads search. One row per distinct ad: who advertised and who paid, the product title with its ASIN and store link, the first and last day the ad was shown, the impressions band in total and per country, the targeting methods, the ad type, and for removed ads the restriction category. No login, no cookies, no API key, no residential proxy. Each ad is charged once per run, a miss costs nothing, and a named memory lets a scheduled run pay only for ads it has not delivered before.

#### What the library holds

Amazon publishes this repository under the EU Digital Services Act for the ads shown on its EU stores; the oldest rows read in testing started in April 2023; there is no US or UK version. The impressions are given as a band in steps of 1,000 ("2,000 to 3,000"), always for one country per ad. The library's own search is a full text search over product titles and advertiser names (whole words, any word matches, best matches first); it has no advertiser filter, which this Actor adds on top, and it does not search payer names.

### Quick start

1. Open the Actor and leave the prefilled input (`searchTerms: ["Nivea"]`, 20 ads): the run returns the library's first page for the word in about five seconds.
2. Put your own words into **Search terms** (a product, a brand, a category), or your competitors' names into **Advertisers** for an exact match on the advertiser name, or ad ids and library URLs into **Ad ids**.
3. Narrow with **Countries** (one search per store), **Shown from** and **Shown until**, **Only these products** (ASINs) and **Row type**; raise **Maximum ads per run**.
4. For monitoring, schedule the same input with a **Memory name**: later runs skip and do not charge the ads already delivered under that name.
5. Read the dataset as JSON, CSV or Excel, or call the Actor through the API (examples below).

### What you get

One `ad` row per distinct ad. Fill rates measured over 20,000 rows read on 2026-10-07 (19,000 ads and 1,000 removed ads).

| Field | What it holds | Fill |
|---|---|---|
| `adId`, `adUrl` | the library's id (40 hex characters; affiliate content rows carry an amzn1. resource id) and the ad's detail page in the library | 100 percent |
| `advertiserName` | who advertised, as the library names it | 100 percent of ads (removed ads carry no name) |
| `payerName`, `payerDiffers` | who paid for the ad; the flag is true when the payer is another name than the advertiser (capitals, spacing and punctuation aside) | 100 percent; the payer differs on about 13 percent of ads |
| `productTitle` | the title of the advertised product | 100 percent of ads |
| `asin`, `productUrl`, `productStore`, `productStoreCountry` | the advertised product's ASIN, link, store (amazon.fr) and country code | 93.8 percent |
| `brandStoreUrl` | the brand store page the ad linked to, where it linked to one | 1.2 percent |
| `firstShown`, `lastShown`, `daysShown`, `daysSinceLastShown` | the days the ad ran (UTC) | 100 percent |
| `impressionsMin`, `impressionsMax`, `impressionsText` | the impressions band of the ad, in steps of 1,000 | 100 percent |
| `impressionsByCountry`, `countriesShown`, `topCountry`, `topCountryImpressionsMax` | the band per country (country, code, store, min, max), largest first | 100 percent (one country per ad) |
| `targetingMethods` | LOCATION, SEARCH_TERMS, PAST_ACTIVITY, ADS_PREFERENCES | 100 percent of ads |
| `adType`, `isAffiliateContent` | AD, or AFFILIATE_MARKETING_CONTENT for creator and publisher content the library lists next to the ads | 100 percent; affiliate rows are about 0.5 percent of results and carry no impressions |
| `isRestricted`, `restrictionCategory`, `restrictionDetectionAutomated`, `illegalContentReport` | whether Amazon removed or restricted the ad and why (Grocery, Creative and Copy Guidelines, Prohibited Content, Health and Personal Care, ...) | 100 percent; the category on removed ads |
| `mediaUrls`, `mediaTypes`, `hasMedia` | links to the ad's creative where the library carries one | 0 percent in the 20,000 rows read (0.16 percent in an earlier read; the links expire after about 30 minutes) |
| `matchedBy`, `source`, `search`, `scrapedAt` | which name matched your input (advertiser or payer), how the row was found, the search that found it | 100 percent |

Three more row types, all free: a `coverage` row per search (the library's total for the text, pages read and charged, rows read, ads delivered, repeats, rows filtered out, the reason the walk stopped, `complete`), a `status` row for anything that did not produce an ad (an id the library does not have, a name without ads, a search with no result, inputs skipped because the run stopped, a memory that could not be used), and one `summary` row with every counter and the billing figures.

#### Modes

- **Search terms**: the library's ranked results for the words, walked page by page (50 ads a page) until the end, your caps or your charge limit. A search with no result is a free row.
- **Advertisers** (exact name): the advertiser name is searched and only ads whose advertiser name equals it (capitals and spacing aside) are delivered; an ad whose payer name equals it counts too when the library's results for the text hold it, but the library does not search payer names (a company that only pays for ads under another advertiser's name is found by that advertiser's name). The library ranks an advertiser's own ads first, so the walk ends after two pages in a row without the name (`advertiserPagesWithoutMatch` raises that for a name that is also a common product word). `advertiserMatch: contains` keeps every name holding your text (LEGO matches LEGO Poland and LEGO France). The pages read before the first ad of the name are free, and so is every page of a name that never matches; a scheduled run that finds nothing new pays for the pages of the name it re-reads (see the pricing section).
- **Ad ids** or library detail URLs: one row per ad found (looked up at the pace and delivered in batches of ten), a free row per id the library does not have.
- **Removed ads**: the library's compliance search, ads Amazon removed or restricted, each with its restriction category. It takes countries and dates, no text.
- No target at all: the first ads of the whole library inside your countries and dates (the sample).

#### Caps and the charge limit

`maxAds` (100 when left out, up to 100,000), `maxAdsPerSearch`, `maxPagesPerSearch` (400 pages of 50 when left out). A run also stops at the charge limit you set on it (a page is asked for only when it and one more ad fit under it) and the rest of the inputs is listed in one free row. Every stop is named in the coverage row and the summary.

Unpaid work has a time allowance: a run may spend 60 seconds, plus 1.5 seconds for every ad and 6 for every results page it has charged, on calls that end without a charge (ad ids the library does not have, names without ads, searches with no result, filters nothing passes, calls that failed), their waits included; the paid calls do not count. At one call per 2.5 seconds that is about 20 misses in a row before anything was charged (fewer when robot pages widened the gap), and a list of ad ids keeps running as long as fewer than about one id in three is a miss; a list with more misses than that ends with the rest of its inputs in one free `skipped` row, so run it again with the rest. Misses are free; the allowance keeps a run from spending its time on a list the library does not hold.

### How much does it cost to scrape the Amazon Ad Library?

Pay per event. The Store pricing card shows these same prices per 1,000 events: "$0.50 / 1,000" on the Ad row means one ad costs 0.05 cents.

| Event | Free | Bronze | Silver | Gold | What it is |
|---|---|---|---|---|---|
| Ad (per 1,000) | $0.50 | $0.50 | $0.45 | $0.40 | one distinct ad delivered as a row, charged once per run however often the library repeats it |
| Results page (per 1,000) | $0.50 | $0.50 | $0.50 | $0.50 | one page of up to 50 results the library answered for a search (0.05 cents a page) |
| Actor start | $0.008 | $0.008 | $0.008 | $0.008 | once per run (per GB of run memory; a 256 MB run pays one) |

Platinum and Diamond plans pay the Gold price. Free: repeated ads, ads an earlier search of the run delivered, ads a named memory already knows, rows dropped by the advertiser name, ASIN or ad type filter, a search with no result, an ad id the library does not have, a call the library refused, the pages a filtered search reads before it first meets an ad it keeps, every page of a name that never matches, coverage rows, status rows and the summary. A page is charged once the search is productive: it delivered an ad, or it met ads of the name that the memory or an earlier search of the run already holds (a monitor that finds nothing new pays for the pages of its competitor's ads it re-read, 0.05 cents each).

Worked examples at the Bronze price: 1,000 ads of a keyword cost $0.50 for the ads, $0.01 for the 20 pages and $0.008 for the start, $0.518 in all; a scheduled run on a memory that finds 3 new ads on 2 pages costs $0.0015 for the ads, $0.001 for the pages and $0.008 for the start, $0.0105; a scheduled run on an advertiser with 127 ads that finds nothing new re-reads 5 pages, $0.0025, plus the start fee. A run of 100 ad ids of which 10 are not in the library costs $0.045 for the 90 ads found plus the start fee, $0.053; the 10 misses are free rows.

### Input

| Field | Type | What it does |
|---|---|---|
| `searchTerms` | list of strings | search texts, one per line (`keywords`, `queries` and `searchText` are read as well) |
| `advertisers` | list of strings | advertiser names, exact match (`advertiserNames`, `brands` as well) |
| `advertiserMatch` | `exact` or `contains` | how a name is compared; `exact` when left out |
| `advertiserPagesWithoutMatch` | 1 to 20 | pages in a row without the name before an advertiser walk ends; 2 when left out |
| `adIds` | list of strings | ad ids or library detail URLs (`adUrls`, `startUrls` as well) |
| `removedAds` | boolean | the removed ads search; send it alone with countries and dates |
| `countries` | list | DE, FR, IT, ES, NL, PL, SE, BE, IE, or names (Germany) or stores (amazon.de); every store when left out |
| `startDate`, `endDate` | string | YYYY-MM-DD, `today`, `yesterday`, `30 days`, `2 weeks`, `3 months`; an ad matches when it was shown on at least one day of the window; the whole library when both are left out |
| `asins` | list of strings | ASINs or product URLs; only ads of these products are delivered |
| `adType` | `all`, `ad`, `affiliate` | every row, only ads, or only affiliate marketing content; `all` when left out |
| `maxAds`, `maxAdsPerSearch`, `maxPagesPerSearch` | integers | the caps; 100, no cap, 400 when left out (`maxItems`, `maxResults`, `limit` are read for `maxAds`) |
| `memoryName`, `resetMemory` | string, boolean | the cross run memory for monitors |
| `proxyConfiguration` | object | Apify's datacenter proxy by default, one address for the whole run; switch it off to use the run's own address; the residential group is replaced by the datacenter pool |

Every value is used as sent or refused: a date that is not a date, a cap that is not a whole number in range, an unknown country or a target field that holds nothing usable ends the run with one free `invalid` row and no charge. An input with no target field at all runs the sample.

#### API examples

```bash
curl -X POST "https://api.apify.com/v2/acts/automation_craft~amazon-ad-library-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"advertisers": ["LEGO Poland"], "countries": ["PL"], "startDate": "90 days", "maxAds": 500}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('automation_craft/amazon-ad-library-scraper').call({ searchTerms: ['Trockenshampoo'], countries: ['DE'], maxAds: 1000, memoryName: 'dry shampoo watch' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const ads = items.filter((x) => x.type === 'ad');
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation_craft/amazon-ad-library-scraper").call(run_input={"removedAds": True, "countries": ["FR"], "maxAds": 200})
rows = [x for x in client.dataset(run["defaultDatasetId"]).iterate_items() if x["type"] == "ad"]
```

### What this Actor does not do

- It does not return the ad creative (image, video, headline, call to action): Amazon's library carries a media link on well under one percent of ads and the links expire after about 30 minutes. The product title, ASIN and link are what the library gives.
- It does not return spend: the library publishes impressions bands, not money.
- It does not return an advertiser profile or page: the library has no advertiser page, only the advertiser name and the payer name on each ad.
- It does not read the live search page (price, rating, the sponsored flag of a search card); that is what a search page scraper such as the Amazon Product Scraper does.
- It cannot search by payer name or by ASIN: the library's search covers advertiser names and product titles. A payer is found through the advertiser it pays for; a product is found by its words, with the `asins` filter keeping only its ads.
- It covers the EU stores only; there is no US or UK ad library.

### FAQ

#### Where can I see my competitors' ads on Amazon?

In Amazon's EU ad library, the public repository this Actor reads: put the competitor's advertiser name into `advertisers` for an exact match, or its brand or product words into `searchTerms`, and every ad comes back with the product advertised, the days it ran and the impressions band per country.

#### How do I find who pays for an ad?

Every row carries `payerName` next to `advertiserName` and `payerDiffers` says whether they are two names (capitals, spacing and punctuation aside); on about 13 percent of the ads read they are. The library does not search payer names, so search for the advertiser or the product and read the payer on the rows.

#### Is the Amazon ad library the same as the Amazon Ads console reports?

No. The console shows an advertiser its own campaigns and never names the others. The library is the public transparency repository the EU Digital Services Act requires: every ad shown on an EU store, with the advertiser, the payer, the dates and the impressions band, for anyone to read.

#### Can I monitor an advertiser and pay only for new ads?

Yes: schedule the same input with a `memoryName`. Ads delivered under that name are remembered in a key value store this Actor creates in your account and skipped, free, on later runs; a run that finds nothing new pays only for the pages it re-read (0.05 cents each) and the start fee. For an advertiser with thousands of ads, add a date window (`startDate: "30 days"`) so each run reads only the ads shown recently. Two runs on one name at the same time, or a memory that cannot be opened or saved, make the run deliver free and remember nothing, and a status row says so.

#### Why does this Actor run with limited permissions?

Least privilege: it reads only its own input, dataset and key value stores, plus the named memory store it creates itself. It needs nothing else from your account.

#### Which countries and dates can I filter?

The nine EU stores (Germany, France, Italy, Spain, the Netherlands, Poland, Sweden, Belgium, Ireland), one search per country, and any date window (an ad matches when it was shown on at least one day of it; the oldest ads read started in 2023). Without filters the whole library is searched.

### Changelog

- 0.1 (2026-10-07): first release. Keyword, advertiser, ad id and removed ads modes; countries, dates, ASIN and ad type filters; one row per distinct ad charged once; a free coverage row per search; the cross run memory.

### More data tools by Automation Craft

- [Meta Ad Library Scraper - All Placements, Filters](https://apify.com/automation_craft/meta-ads-library-scraper)
- [Google Ads Transparency Scraper - Decoded Creatives](https://apify.com/automation_craft/google-ads-transparency-scraper)
- [TikTok Ads Library Scraper: EU Ads, No Login](https://apify.com/automation_craft/tiktok-ads-library-scraper)
- [LinkedIn Ad Library Scraper: Ads by Company](https://apify.com/automation_craft/linkedin-ad-library-scraper)
- [Microsoft Ads Library Scraper - Competitor Ads](https://apify.com/automation_craft/microsoft-ads-library-scraper)
- [Bing Ads Library Scraper - Advertisers, Ad Copy](https://apify.com/automation_craft/bing-ads-library-scraper)
- [Pinterest Ads Library Scraper - EU Ads Repository](https://apify.com/automation_craft/pinterest-ads-library-scraper)
- [Amazon Product Scraper - Search, Best Sellers](https://apify.com/automation_craft/amazon-data-scraper)

# Changelog

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

# Actor input Schema

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

One search text per line, for example Trockenshampoo or Nivea Creme. Each returns the library's ads whose product title or advertiser name holds any of the words, best matches first, walked page by page until the end or your caps. Up to 200 per run.

## `advertisers` (type: `array`):

One advertiser name per line, exactly as the library writes it (capitals and spacing do not matter), for example LEGO Poland or xiepiao. The name is searched and only ads whose advertiser name equals it are delivered (an ad whose payer name equals it counts too when the results hold it); the walk ends after two pages in a row without such an ad (the library ranks that advertiser's own ads first). A name with no such ad at the top of its results comes back as a free row. The library's search does not cover payer names: a company that only pays for ads under another advertiser's name is found by that advertiser's name. Up to 200 per run.

## `advertiserMatch` (type: `string`):

exact: the advertiser name (or the payer name, where the results hold it) must equal your text (capitals and spacing aside). contains: any such name containing your text counts (LEGO matches LEGO Poland and LEGO France). Through the API send exact or contains. When the field is left out, exact is used.

## `adIds` (type: `array`):

One per line: an ad id (40 characters, for example 978bd06d92ce441e2cddb159e5257ccf7ff676ab; affiliate content rows carry ids such as amzn1.vse.video.1013900da28f4e8e8fec6c1fc808dd35) or a detail page URL of the library (https://www.amazon.de/adlibrary/detail/978bd06d92ce441e2cddb159e5257ccf7ff676ab). Each ad found comes back as one row and is charged as one Ad. An id the library does not have costs nothing and comes back as a free row. Up to 5,000 per run.

## `removedAds` (type: `boolean`):

Search the ads Amazon removed or restricted (the library's compliance search) instead of the ad search: every row carries the restriction category and whether the detection was automated. The library takes no search text with it: send it alone, with countries and dates only. Off when the field is left out.

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

Keep ads that were shown in these countries, one search per country. Leave empty for every store. Through the API send ISO codes (DE, FR, IT, ES, NL, PL, SE, BE, IE), country names (Germany) or store hosts (amazon.de).

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

First day of the window: YYYY-MM-DD, or a number of days, weeks or months back from the end date, such as 30 days. An ad is returned when it was shown on at least one day of the window. When the field is left out, the whole library is searched (no date filter).

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

Last day of the window: YYYY-MM-DD, today or yesterday. Today when a start date is given without it; no date filter when both are left out.

## `asins` (type: `array`):

One ASIN (B000SI95R8) or Amazon product URL per line. Only ads whose advertised product is one of them are delivered; the other rows of the pages read are dropped free. The library cannot search by ASIN, so give the product's words as a search term or its brand as an advertiser next to this filter.

## `adType` (type: `string`):

all: every row. ad: only paid ads. affiliate: only affiliate marketing content (commercial communications by creators and publishers, which the library lists next to the ads). Through the API send all, ad or affiliate; all when the field is left out.

## `maxAds` (type: `integer`):

The run stops when this many ads were delivered. 100 when the field is left out; up to 100,000.

## `maxAdsPerSearch` (type: `integer`):

A cap for each search term and each advertiser (per country when countries are given). 0 or empty: no cap per search.

## `maxPagesPerSearch` (type: `integer`):

A search stops after reading this many pages of 50 results. 400 when the field is left out (20,000 results); up to 20,000.

## `advertiserPagesWithoutMatch` (type: `integer`):

In the advertiser mode the walk ends after this many pages in a row without an ad of the name. 2 when the field is left out; raise it for a name that is also a common product word (NIVEA), where the advertiser's ads are mixed with other sellers' ads of that product. Up to 20.

## `memoryName` (type: `string`):

A plain name, for example competitor watch. Ads delivered under this name are remembered in a key value store this Actor creates in your account; on later runs with the same name they are skipped and not charged. Two runs on one name at the same time: the second one delivers its ads free and remembers nothing. A memory that cannot be opened or saved makes the run free too.

## `resetMemory` (type: `boolean`):

Forget everything stored under the memory name before the run, so every ad counts as new again.

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

Apify's datacenter proxy by default, one address kept for the whole run, one call every 2.5 seconds. The residential group is replaced by the datacenter pool (the library answers datacenter addresses and residential traffic would cost more than an ad earns). Switch the proxy off to use the run's own address.

## Actor input object example

```json
{
  "searchTerms": [
    "Nivea"
  ],
  "maxAds": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (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 = {
    "searchTerms": [
        "Nivea"
    ],
    "maxAds": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_craft/amazon-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 = {
    "searchTerms": ["Nivea"],
    "maxAds": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("automation_craft/amazon-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 '{
  "searchTerms": [
    "Nivea"
  ],
  "maxAds": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call automation_craft/amazon-ad-library-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation_craft/amazon-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/JTQgj92gJ4BzfPpLc/builds/ttVAUC2Z8VxU3dmEp/openapi.json