# Amazon Ad Library Scraper — EU Ads Repository (DSA) (`rastriq/amazon-ad-library-scraper`) Actor

Scrape the Amazon Ad Library (EU DSA ad repository): advertiser, payer, delivery dates, reach per country and store, targeting methods, landing pages, video creatives and restricted ads for amazon.de, .fr, .it, .es, .nl, .pl, .se, .ie and .com.be.

- **URL**: https://apify.com/rastriq/amazon-ad-library-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** Marketing, E-commerce
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Repository (DSA)

**Amazon Ad Library Scraper** extracts ads from the official [Amazon Ad Library](https://www.amazon.de/adlibrary), the EU ad repository Amazon publishes under the Digital Services Act: advertiser, payer, delivery dates, reach per country and per Amazon store, targeting methods, landing pages, video creatives and ads restricted for policy reasons. Use it as an Amazon Ad Library API for competitor research, seller and brand monitoring, and DSA transparency analysis.

### 🔎 What is Amazon Ad Library Scraper?

Amazon's own Ad Library lets you browse one search at a time and scroll through 50 ads per click. **Amazon Ad Library Scraper** turns it into structured data you can export, schedule and join with other ad libraries:

- 🔍 **Search by brand, seller or product** — every term is paginated to its last page, not just the first screen
- 🌍 **All EU Amazon stores** — amazon.de, .fr, .it, .es, .nl, .pl, .se, .ie and .com.be, together or store by store
- 👥 **Reach** — total recipients and the breakdown per country and per Amazon store
- 🏢 **Who's behind it** — advertiser (brand or seller) and the legal entity that paid
- 🎯 **Targeting methods** — location, past activity, search terms, ads preferences…
- 🎬 **Creatives** — landing page (product, Store page) and video/audio files, optionally downloaded before Amazon's links expire
- 🚫 **Restricted ads** — ads Amazon removed for policy reasons, with category and whether detection was automated
- 🤝 **Commercial communications** — affiliate and influencer content Amazon discloses separately
- ✅ **Data quality** — each row carries `quality_flags` and a DSA art. 39 coverage score; nothing is silently dropped

Typical uses: tracking competitors' Sponsored Brands activity, finding which sellers advertise a product category, reach benchmarking by country, and compliance or academic research on EU advertising.

### 📦 What data does Amazon Ad Library Scraper extract?

Every row has a common block shared by all Rastriq ad-library scrapers, plus **every field Amazon publishes, with Amazon's original names**.

| Group | Fields |
|---|---|
| 🆔 Identity | `platform`, `ad_id`, `source_url`, `scraped_at` |
| 🏢 Advertiser | `advertiser`, `payer` (+ native `advertiserName`, `payerName`) |
| 📅 Period | `first_shown`, `last_shown` (+ `deliveryAfterDateUtc`, `deliveryBeforeDateUtc`) |
| 👥 Reach | `reach_min`, `reach_max`, `reach_by_country`, `countries` (+ `totalRecipientsRange`, `totalRecipientsRangeBySite`, `recipientsBreakdown`) |
| 🎯 Targeting | `targeting_types` (+ `targetingMethods`, `targetingParameters`) |
| 🎨 Content | `advertisementPurpose` (ad text), `type`, `destination_url`, `creative_urls`, `media[]` (+ `contentUrls`, `contents`, `subjectMatterUrl`) |
| 🚫 Moderation | `isRestricted`, `restrictionCategory`, `restrictionDetectionAutomated`, `illegalContentReport` |
| ✅ Quality | `quality_flags[]`, `art39_coverage`, `is_natural_person_suspected`, `natural_person_fields` |
| 🔁 Traceability | `query_search_term`, `query_marketplace`, `query_start_date`, `query_end_date` |

#### 📄 Flat table or nested JSON

By default every row is a **flat table** — one value per column, ready for Excel, Google Sheets or CSV: lists become comma-separated text (URLs are separated by `|`), reach per country becomes `reach_min_<CC>` / `reach_max_<CC>` columns, and the DSA art. 39 score becomes `art39_covered`, `art39_total`, `art39_ratio` and `art39_missing`. Set **Output format** to *Nested JSON* to keep the source's original objects and lists for programmatic use.

### 🚀 How to use Amazon Ad Library Scraper

1. Open **Amazon Ad Library Scraper** in Apify Console and click **Try for free**.
2. Add one or more **Search terms**: brands (`PUMA`), sellers (`Vebon`) or products (`Fire TV Stick`).
3. Pick the **Marketplaces** (all EU stores by default) and the **From / To** period.
4. Set **Max ads** (100 is a good first test).
5. Click **Start** and download the results as JSON, CSV, Excel or via API.
6. Optional: schedule the run weekly to follow a competitor's new ads.

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | array | — | Brands, sellers or products. Empty = browse all ads of the period |
| `maxItems` | integer | `1000` | Max ads in the run (0 = no limit) |
| `marketplaces` | array | `["ALL"]` | `ALL`, `DE`, `FR`, `IT`, `ES`, `NL`, `BE`, `PL`, `SE`, `IE` |
| `startDate` / `endDate` | string | `30 days` / today | Ads delivered in the period. `YYYY-MM-DD` or relative |
| `adIds` | array | — | Fetch specific ads by id |
| `advertiserMatch` | string | `any` | `any` (as Amazon returns), `contains`, `exact` |
| `payerFilter` | array | — | Keep ads whose payer contains any of these texts |
| `adTypes` | array | both | `AD`, `AFFILIATE_MARKETING_CONTENT` |
| `restrictedAds` | string | `exclude` | `exclude`, `include`, `only` — restricted ads are listed per marketplace (Amazon has no text search for them) |
| `mediaMode` | string | `reference` | `reference`, `signed` (30-min link), `download` |
| `hashPersonalNames` | boolean | `false` | Pseudonymise names flagged as private individuals |
| `outputFormat` | string | `flat` | `flat` (one column per value) or `nested` (original JSON structure) |
| `maxItemsPerQuery` | integer | `0` | Cap per search term × marketplace |

```json
{
  "searchTerms": ["PUMA", "Vebon"],
  "marketplaces": ["DE", "FR", "IT"],
  "startDate": "2026-01-01",
  "advertiserMatch": "contains",
  "maxItems": 500
}
```

### 📤 Output example

One row of the default flat output (selected columns):

```json
{
  "platform": "amazon",
  "ad_id": "d2d3badd9d69123a530acf924129e381c1f21de2",
  "advertiser": "Vebon",
  "payer": "Prime Trade GmbH",
  "first_shown": "2024-03-27",
  "last_shown": "2026-11-09",
  "reach_min": 158000,
  "reach_max": 159000,
  "reach_min_DE": 0,
  "reach_max_DE": 1000,
  "reach_min_IT": 1000,
  "reach_max_IT": 2000,
  "countries": "AT, BE, BG, CY, CZ, DE, DK, ES, FI, FR, GR, HU, IE, IT, LT, LU, LV, MT, NL, PL, PT, RO, SE, SI",
  "targeting_types": "LOCATION, PAST_ACTIVITY, SEARCH_TERMS",
  "destination_url": "https://www.amazon.it/dp/B08BWQHTBR",
  "source_url": "https://www.amazon.de/adlibrary/detail/d2d3badd9d69123a530acf924129e381c1f21de2",
  "advertisementPurpose": "Vebon® Raccoglitore ad anelli A4 \"Parigi\" I zip + portadocumenti + tasca per computer portatile I Spazio ag…",
  "type": "AD",
  "totalRecipientsRangeBySite_Italy_min": 158000,
  "totalRecipientsRangeBySite_Italy_max": 159000,
  "recipientsBreakdown": "AMAZON_IT/AT: 0-1000; AMAZON_IT/BE: 0-1000; AMAZON_IT/BG: 0-1000; AMAZON_IT/CY: 0-1000; AMAZON_IT/CZ: 0-100…",
  "quality_flags": "possibly_still_running, country_breakdown_below_total, subject_matter_url_not_available",
  "art39_ratio": 1.0,
  "art39_missing": null,
  "is_natural_person_suspected": false,
  "scraped_at": "2026-11-11T14:37:06Z"
}
```

…plus one `reach_min_<CC>` / `reach_max_<CC>` pair per country, `totalRecipientsRangeBySite_<Store>_min/_max`, `media_types`, `media_expires_at` and every other field Amazon publishes.

`quality_flags` marks what deserves a second look: `country_breakdown_below_total` (Amazon's per-country rows do not add up to the total), `possibly_still_running`, `restricted_details_withheld`, `advertiser_not_matching_query`, `no_reach_disclosed`, `natural_person_suspected`… You decide what to keep.

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

Amazon Ad Library Scraper uses pay-per-event pricing with volume discounts by Apify plan. You pay per ad delivered to your dataset plus a small start fee per run. Ads removed by your filters and ads already delivered earlier in the same run are free.

| Apify plan | Price per 1,000 ads | Run start |
|---|---|---|
| Free | $0.60 | $0.002 |
| Starter (Bronze) | $0.50 | $0.002 |
| Scale (Silver) | $0.40 | $0.0015 |
| Business (Gold) | $0.30 | $0.001 |

- **Free plan ($5 credit)**: ~8,000 ads
- **Starter plan ($49/mo)**: ~95,000 ads
- **Downloaded media files** (`mediaMode: download` only): $0.01 per file

> 💡 **Tip**: run 100 ads first; 1,000 ads take about 30–40 seconds (20 pages at the default request delay).

### 🔗 Related Actors

Build a cross-platform view of competitor advertising with the Rastriq ad intelligence suite:

- [Facebook Ad Library Scraper](https://apify.com/Rastriq/fb-adlibrary-scraper) — Meta ads (Facebook & Instagram)
- [Google Ads Transparency Center Scraper](https://apify.com/Rastriq/google-ads-scraper) — Search, YouTube and Display ads
- [TikTok Ad Library Scraper](https://apify.com/Rastriq/tiktok-ad-library-scraper) — TikTok ads, targeting and reach
- [LinkedIn Ad Library Scraper](https://apify.com/Rastriq/linkedin-ad-library-scraper) — B2B ads on LinkedIn
- [X (Twitter) Ads Library Scraper](https://apify.com/Rastriq/x-ads-repository-scraper) — X ads, reach and targeting in the EU

All of them share the same base fields (`platform`, `ad_id`, `advertiser`, `payer`, `first_shown`, `reach_by_country`…), so their datasets can be stacked in one table.

### ❓ FAQ

**Which ads are included?** Ads shown on Amazon's EU stores, which is what Amazon publishes under the Digital Services Act, including ads that started before your period but were still delivered in it. Ads shown only outside the EU are not in the library.

**How does the search work?** Amazon matches each term against the advertiser name and the ad text, ranked by relevance; payers are not searchable. A term like `PUMA` also returns sellers whose product text mentions PUMA — those rows are flagged `advertiser_not_matching_query`. Set **Advertiser match** to `contains` to keep only the brand's own ads.

**Why does the "total" in the run summary not match Amazon's website?** Amazon only reports a reliable total on the first page of results. Amazon Ad Library Scraper stores it as `totalResultsReported` in the run's `OUTPUT` record and counts the ads it actually paginated through.

**Why are there no video links in my export?** Amazon's media links are signed and expire 30 minutes after they are issued. By default you get a stable reference to the file. Choose **Signed link** to get a downloadable link (with `expiresAt`), or **Download files** to keep the files in the run's storage.

**Does it collect personal data?** Some advertisers and payers on Amazon are private individuals (sole traders, authors, influencers). Amazon Ad Library Scraper flags those rows with `is_natural_person_suspected` instead of hiding them, and can replace the names with a stable pseudonym (`hashPersonalNames`). You are responsible for processing that data lawfully (GDPR).

**Is it legal to scrape the Amazon Ad Library?** The Actor only reads the public, logged-out transparency repository that Amazon publishes by law, at a moderate request rate. You are responsible for complying with Amazon's terms and applicable laws in how you use the data.

**Something broke?** Open an issue in the Actor's **Issues** tab — we usually reply within 24 hours.

# Changelog

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

# Actor input Schema

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

Brands, sellers or products. Amazon matches each term against the <b>advertiser name and the ad text</b> (not the payer), ranked by relevance.<br><br>Examples: <code>PUMA</code>, <code>Vebon</code>, <code>Fire TV Stick</code><br><br>Leave empty to browse <b>all ads</b> of the period (use <b>Max ads</b>). Use <b>Advertiser match</b> below to keep only ads whose advertiser contains the term.

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

Maximum number of ads in the dataset for the whole run. <b>0 = no limit</b> (a search is paginated to its last page).<br><br>Amazon holds hundreds of millions of ads; a search without terms over a long period is effectively endless — always set a limit for it.

## `marketplaces` (type: `array`):

Amazon EU stores to query. <b>All</b> runs one query across every store; selecting stores runs one query per store and merges results (an ad shown in several stores is delivered once).

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

Ads <b>delivered at any time</b> in the period are returned, including long-running ads that started earlier. Absolute (<code>2026-01-01</code>) or relative (<code>30 days</code>, <code>6 months</code>).

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

End of the period. Empty = today.

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

Fetch specific ads by their Amazon Ad Library id (the <code>ad_id</code> field, or the last part of <code>amazon.de/adlibrary/detail/\<id></code>). Can be combined with search terms.

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

<b>As returned by Amazon</b> keeps every result (the term may only appear in the ad text — those rows get the flag <code>advertiser_not_matching_query</code>).<br><b>Advertiser contains the term</b> keeps only ads whose advertiser name contains it.<br><b>Exact advertiser</b> keeps only an exact (case-insensitive) match.

## `payerFilter` (type: `array`):

Keep only ads whose payer contains any of these texts (case-insensitive), e.g. <code>GmbH</code> or a legal entity name. Amazon cannot search by payer, so combine it with search terms.

## `adTypes` (type: `array`):

<b>Ads</b> = sponsored ads. <b>Commercial communications</b> = affiliate / influencer content Amazon discloses under the DSA (no payer, reach or end date).

## `restrictedAds` (type: `string`):

Ads Amazon removed or restricted for policy reasons (DSA moderation), with the restriction category and whether detection was automated; advertiser and payer are usually withheld.<br><br>⚠️ Amazon does not allow text search on restricted ads: they are listed <b>per marketplace and period</b>, ignoring search terms (use <b>Max ads</b>).

## `outputFormat` (type: `string`):

<b>Flat</b> (default): every value in its own column — lists become comma-separated text, reach per country becomes <code>reach_min_DE</code> / <code>reach_max_DE</code> columns, and art. 39 coverage becomes <code>art39_ratio</code> / <code>art39_missing</code>.<br><br><b>Nested</b>: keeps the source's original objects and lists (e.g. the full per-language variations or per-country breakdown) for programmatic use.

## `mediaMode` (type: `string`):

Amazon serves video/audio/image creatives through <b>signed links that expire after 30 minutes</b>.<br><br>• <b>Reference</b> — stable link without the signature (identifies the file; not downloadable)<br>• <b>Signed link</b> — downloadable for ~30 min after the run (<code>media\[].expiresAt</code>)<br>• <b>Download</b> — saves each file to the run's key-value store and links it in <code>creative_urls</code>. Charged per file.

## `maxMediaMb` (type: `integer`):

Skip downloads larger than this (flag <code>media_too_large_not_downloaded</code>). Only with <b>Download files</b>.

## `hashPersonalNames` (type: `boolean`):

Some advertisers and payers are private individuals (sole traders, authors, influencers). Every such row is flagged with <code>is_natural_person_suspected</code>. Turn this on to also replace those names with a stable SHA-256 pseudonym (<code>sha256:…</code>) in both the base and the native fields.

## `maxItemsPerQuery` (type: `integer`):

Cap for each search term × marketplace. 0 = no cap (only <b>Max ads</b> applies).

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

Not needed normally. Each retry already starts a new session.

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

Searches run in parallel (requests are still spaced by <b>Request delay</b>).

## `requestDelayMs` (type: `integer`):

Pause between requests to Amazon (randomised ±30 %). Minimum 1000 ms.

## `maxRetries` (type: `integer`):

Retries for temporary errors (429/5xx/blocked page), each with exponential backoff and a fresh session.

## Actor input object example

```json
{
  "searchTerms": [
    "PUMA",
    "Vebon"
  ],
  "maxItems": 100,
  "marketplaces": [
    "ALL"
  ],
  "startDate": "30 days",
  "advertiserMatch": "any",
  "adTypes": [
    "AD",
    "AFFILIATE_MARKETING_CONTENT"
  ],
  "restrictedAds": "exclude",
  "outputFormat": "flat",
  "mediaMode": "reference",
  "maxMediaMb": 50,
  "hashPersonalNames": false,
  "maxItemsPerQuery": 0,
  "maxConcurrency": 1,
  "requestDelayMs": 1500,
  "maxRetries": 4
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `reach` (type: `string`):

No description

## `creatives` (type: `string`):

No description

## `compliance` (type: `string`):

No description

## `allFields` (type: `string`):

No description

## `runSummary` (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": [
        "PUMA",
        "Vebon"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/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": [
        "PUMA",
        "Vebon",
    ],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/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": [
    "PUMA",
    "Vebon"
  ],
  "maxItems": 100
}' |
apify call rastriq/amazon-ad-library-scraper --silent --output-dataset

```

## MCP server setup

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