# Amazon Seller Email Scraper — VAT, Phone & Address Leads (`scrapersdelight/amazon-seller-leads-scraper`) Actor

Turn any Amazon search or product URL into EU third-party seller leads: legal business name, email, phone, VAT ID, trade register number and full address from the DSA seller-transparency panel, plus ratings and feedback history. 9 EU marketplaces. $3 per 1,000 rows, no start fee.

- **URL**: https://apify.com/scrapersdelight/amazon-seller-leads-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Lead generation, E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 per seller returneds

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Amazon Seller Email Scraper — VAT, Phone & Address Leads

Turn an Amazon search, a product URL or a seller ID into a **B2B lead record for the third-party
business behind the listing**: legal company name, e-mail, phone, VAT number, trade-register number,
business address and customer-service address — plus the seller's full ratings history and recent
buyer feedback.

The contact data is not scraped out of hiding. Every EU marketplace seller is legally required to
publish it under the **Digital Services Act / EU trader-transparency rules**, and Amazon renders it
on the public seller-profile page as the *Detailed Seller Information* panel. This actor reads that
panel and hands you the whole record as one clean row.

**One row per unique seller**, deduplicated on seller ID — not one row per product. A seller found on
ten listings is billed once.

***

### What it does

| | |
|---|---|
| 🔎 **Search → sellers** | Type a keyword. Every product on the results page is opened, the third-party merchant behind it is resolved, and that merchant's public profile is scraped. |
| 🔗 **Product URL → seller** | Paste product URLs or bare ASINs and get the sellers behind exactly those listings. |
| 🎯 **Seller ID → record** | Already have seller IDs or storefront URLs? Skip discovery — one request per lead. |
| 🏛️ **Full DSA imprint** | Legal name, business type, trade register number + court, VAT ID, phone, fax, e-mail, business address, **and the separate customer-service address and phone**. |
| ⭐ **Four rating windows** | 1 month / 3 months / 12 months / lifetime, each with its own score *and* count, plus the 5-star percentage histogram and recent feedback comments with seller replies. |
| 🌍 **11 marketplaces** | 9 EU sites (`.de .it .es .fr .nl .se .pl .com.be .ie`) plus `.co.uk` and `.com.tr`. Proxy country is pinned to the marketplace automatically. |
| 🚫 **No login** | Public pages only. No account, no target-site cookies, no CAPTCHA-solving services. |

***

### Quick start

```jsonc
{
  "marketplace": "amazon.it",
  "searchTerms": ["ricambi trattore"],
  "maxSellers": 30
}
```

Other ways in:

```jsonc
// specific products
{ "marketplace": "amazon.de", "productUrls": ["https://www.amazon.de/dp/B0CX1JN6WF", "B0D4QVBR6R"] }

// sellers you already know — one request per lead, no discovery cost
{ "marketplace": "amazon.it",
  "sellerUrls": ["A1YYMKC9INWJTB", "https://www.amazon.it/s?me=AI18FTVVOEZ7J"] }
```

> **Keyword choice is the single biggest lever on yield.** Third-party density is a property of the
> search term, not the site. Spare parts, accessories, industrial and niche supplies are dominated by
> marketplace sellers. A big-brand or Amazon-own-label keyword returns first-party listings, which
> carry **no seller imprint at all** — the run will honestly report *"N products were sold by Amazon
> itself, not third parties"* rather than pretending it failed.

***

### Output

**61 fields per row.** Example (real row, trimmed):

```json
{
  "sellerId": "A1YYMKC9INWJTB",
  "marketplaceDomain": "amazon.it",
  "marketplaceId": "APJ6JRA9NG5V4",
  "storeName": "BSSW Europe GmbH",
  "sellerLogoUrl": "https://m.media-amazon.com/images/I/01AbK-Y2KQL.jpg",
  "sellerProfileUrl": "https://www.amazon.it/sp?ie=UTF8&seller=A1YYMKC9INWJTB",
  "storefrontUrl": "https://www.amazon.it/s?me=A1YYMKC9INWJTB",
  "contactSellerUrl": "https://amazon.it/gp/help/contact-seller/contact-seller.html?sellerID=…",
  "leaveFeedbackUrl": "https://www.amazon.it/gp/feedback/leave-consolidated-feedback.html?…",

  "isBusinessSeller": true,
  "businessName": "BSSW Europe GmbH",
  "businessType": "Impresa privata",
  "tradeRegisterNumber": "HRB 23899",
  "tradeRegisterCourt": "Aachen",
  "vatNumber": "IT00281799999",
  "phone": "+4924054069355",
  "fax": "+49 (0) 2405 / 40 693-56",
  "email": "amazon@bssw-europe.com",
  "businessAddress": "Adenauerstraße, 20 A2, Würselen, 52146, DE",
  "businessAddressLines": ["Adenauerstraße", "20 A2", "Würselen", "52146", "DE"],
  "customerServiceAddress": "Adenauerstr. 20A2, 3.OG, valonic Geb A2, 3.OG, Würselen, NRW, 52146, DE",
  "customerServicePhone": "+4924054069355",
  "addressCity": "Würselen", "addressRegion": null,
  "addressPostalCode": "52146", "addressCountryCode": "DE",
  "aboutBlurb": "BSSW Europe GmbH\n\nAdenauerstr. 20 (A2, 3.OG)\n\n52146 Würselen\n\nTelefono: +49 (0) 2405 / 40 693-55\n\nFax: …",
  "odrPlatformLinks": null,
  "imprintRaw": { "Venditore Business": true, "Nome azienda": "BSSW Europe GmbH", "…": "…" },

  "ratingOverall": 5,
  "positiveFeedbackPct12mo": 100,
  "rating1Month": 4.8,  "ratingCount1Month": 14,
  "rating3Months": 4.9, "ratingCount3Months": 56,
  "rating12Months": 4.9,"ratingCount12Months": 188,
  "ratingLifetime": 4.9,"ratingCountLifetime": 1100,
  "starDistribution5Pct": 86, "starDistribution4Pct": 14,
  "starDistribution3Pct": 0,  "starDistribution2Pct": 0, "starDistribution1Pct": 0,
  "recentFeedbackReviews": [
    { "rating": 4, "text": "ok", "author": "Cliente Amazon",
      "date": "2 settembre 2026", "sellerReply": null }
  ],

  "sellerResolverStrategy": "anchor",
  "isAmazonFulfilled": true,
  "sourceAsin": "B0CX1JN6WF",
  "sourceProductTitle": "fouraces fanali posteriori per rimorchio - 2 set, con schema elettrico …",
  "sourceProductPrice": 16.99,
  "sourceProductCurrency": "€",
  "sourceProductUrl": "https://www.amazon.it/dp/B0CX1JN6WF",
  "catalogueSize": 78,
  "discoveredFromKeyword": "ricambi trattore",
  "scrapedAt": "2026-09-03T03:04:17.998Z"
}
```

#### Field table + MEASURED fill rate

Fill measured on a **real Apify run (run `LQIpWcySsXWQQuXf8`, 2026-09-03, `amazon.it`, three
keywords, 29 seller rows, 125 s at 1 GB)**. These are the actual numbers, not estimates.

| Field | What it is | Fill |
|---|---|---|
| `sellerId` | Amazon merchant ID (the dedupe key) | **100%** |
| `marketplaceDomain` / `marketplaceId` | Site scraped + Amazon's internal marketplace ID | **100%** |
| `storeName` | Public store name | **100%** |
| `sellerProfileUrl` / `storefrontUrl` / `contactSellerUrl` | Ready-to-open links | **100%** |
| `leaveFeedbackUrl` | Feedback form link | 97% |
| `sellerLogoUrl` | Store logo image | 38% |
| `isBusinessSeller` | Business seller flag from the imprint panel | **100%** (all `true`) |
| `email` | Imprint e-mail | **100%** |
| `phone` | Imprint phone | **100%** |
| `vatNumber` | VAT / USt-IdNr / Partita IVA / Btw-nummer | **100%** |
| `businessName` | Legal company name | 90% |
| `businessType` | e.g. *Impresa privata* / *Unternehmen in Privatbesitz* | 90% |
| `tradeRegisterNumber` | Company / trade register number | 90% |
| `businessAddress` + `businessAddressLines` | Registered address (joined + as lines) | 90% |
| `addressCity` / `addressPostalCode` / `addressCountryCode` | Parsed address parts | 90% |
| `addressRegion` | Region/state, when the panel carries one | 72% |
| `customerServicePhone` | Support phone — **distinct** from the imprint phone | 45% |
| `customerServiceAddress` + `…Lines` | Support address — **distinct** from the business address | 34% |
| `tradeRegisterCourt` | Register court (e.g. *Aachen*) | 7% |
| `fax` | Fax number | 3% |
| `odrPlatformLinks` | EU Online Dispute Resolution URLs | 7% |
| `aboutBlurb` | Free-text seller description / German-style *Impressum* text | **100%** |
| `imprintRaw` | Every label→value pair verbatim, including labels this actor does not map | **100%** |
| `imprintFound` / `imprintStrategy` | Whether the DSA panel was found, and how | **100%** |
| `ratingOverall`, `positiveFeedbackPct12mo`, `ratingCountHeader` | Headline rating block | 97% |
| `rating12Months` / `ratingCount12Months` | 12-month window | 97% |
| `ratingLifetime` / `ratingCountLifetime` | Lifetime window | 97% |
| `ratingCount1Month` / `ratingCount3Months` | Short-window counts | 97% |
| `rating1Month` / `rating3Months` | Short-window scores (`null` when that window has 0 ratings — not `0`) | 66% / 86% |
| `starDistribution5Pct` … `1Pct` | 5-star histogram | 97% |
| `recentFeedbackReviews[]` | `{rating, text, author, date, sellerReply}` | 97% |
| `sellerResolverStrategy` | Which resolver found the merchant (`anchor` / `a-state` / `legacy-sp` / `input`) | **100%** |
| `sourceAsin`, `sourceProductTitle`, `sourceProductPrice`, `sourceProductCurrency`, `sourceProductUrl` | The listing the seller was found on | **100%** |
| `isAmazonFulfilled` | FBA flag from the merchant link (`null` when the link omits it) | 45% `true` |
| `catalogueSize` | Products in the seller's storefront (opt-in, extra request) | 90% |
| `discoveredFromKeyword` | Keyword that surfaced the seller | **100%** |
| `scrapedAt` | ISO timestamp | **100%** |
| `otherSellersCount` / `otherSellersMinPrice` | Competing offers on the source listing | **0%** — see honest limits |

Four dataset views ship with the actor: **Seller leads**, **Full imprint record**, **Ratings** and
**Where the seller was found**.

***

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `marketplace` | enum | `amazon.it` | `.it .de .es .fr .nl .se .pl .com.be .ie .co.uk .com.tr` |
| `searchTerms` | string\[] | `[]` | Keywords to search |
| `productUrls` | string\[] | `[]` | Product URLs or bare ASINs |
| `sellerUrls` | string\[] | `[]` | Seller profile / storefront URLs, or bare seller IDs |
| `maxSellers` | int | `25` | Unique sellers to return. `0` = no limit |
| `maxPagesPerTerm` | int | `1` | Search pages per keyword (1 page ≈ 60 products) |
| `includeFeedbackReviews` | bool | `true` | Recent buyer comments — free, same page |
| `maxFeedbackReviews` | int | `5` | Cap on the comments array |
| `includeCatalogueSize` | bool | `false` | Adds one storefront fetch per seller (~+45% requests) |
| `requestConcurrency` | int | `4` | Higher raises the anti-bot rate, not the speed |
| `proxyConfiguration` | proxy | Apify **Residential**, country auto-pinned | Bring your own residential proxy here if you prefer |

Run it with **no input at all** and it executes a documented 5-seller demo on `amazon.it` rather than
failing — handy for a first click, and it is what the platform's daily test runs.

***

### Pricing

**Pay per event — $3.00 per 1,000 sellers ($0.003 each). No start fee, no per-result surcharge, no
usage add-on.** One line item on your bill.

| Event | Rate |
|---|---|
| `seller-scraped` — per unique seller returned | **$0.003** |

Rows are delivered through Apify's budget-aware push, so **delivered == billed**: if you set a charge
cap, the actor stops at the cap instead of handing you rows you already paid past.

***

### Notes / honest limits

Measured, not assumed. Where a number is quoted it came from a run you can re-run.

**Residential proxy is mandatory — this is the real cost of the actor.** From a plain home or
datacenter IP, `https://www.amazon.it/s?k=…` returns **HTTP 200 with a ~2,232-byte Akamai
`bm-verify` stub**, not a page. Judge Amazon on bytes, never on status: a 200 can be a block. The
default configuration uses Apify Residential with the proxy country pinned to the marketplace, and
you can substitute your own residential proxy in `proxyConfiguration`.

**HTTP/2 had to be turned off, and the difference is large.** Measured 2026-09-03, same proxy, same
headers, same minute, 8 attempts each: with HTTP/2 on, `amazon.se` 0/8, `amazon.pl` 0/8,
`amazon.co.uk` 1/8 usable; with HTTP/2 off, 6/8, 4/8 and 5/8. The actor ships with it off.

**Marketplace availability is not uniform.** In the same session, `amazon.it`, `.de`, `.es` and `.nl`
served cleanly on the first or second attempt. `amazon.fr` is the outlier: it is behind **two**
different walls — Akamai's `bm-verify` interstitial (which this actor solves inline: on `.fr` its
arithmetic proof-of-work was solved and the full 1.7 MB page recovered, and on the measured
`amazon.it` run the same solver fired and succeeded 4 times out of 4) **and** an AWS WAF
`challenge.js` page (HTTP 202, 2,007 bytes,
`server: CloudFront`) which cannot be answered over plain HTTP and is simply retried on a fresh exit.
Across 6 attempts on `.fr` only 1 got through. Expect thin or empty results on `amazon.fr`; the other
marketplaces are fine.

**Cost per lead, measured.** The 29-row run above spent **165 requests** — about 5.7 requests per
delivered lead *with* `includeCatalogueSize` on and including every retry the residential pool
needed (48 transient proxy errors, all recovered). Turn `includeCatalogueSize` off and pass seller
IDs directly and it drops to roughly one request per lead.

**`otherSellersCount` / `otherSellersMinPrice` filled 0 of 29.** Amazon's "other sellers" panel is
now rendered entirely client-side, and all three of its AJAX endpoints return **HTTP 404 with a
2,233-byte body** (`/gp/aod/ajax/ref=auto_load_aod`, `/gp/product/ajax/ref=aod_f_new`,
`/gp/product/ajax?…experienceId=aodAjaxMain`, verified 2026-09-03). The fields are still emitted —
they populate on the marketplaces and page variants that still render the text form — but do not
plan around them today.

**Address parsing is a best-effort split of an unlabelled block.** Amazon prints the address as
ordered lines with no field names. Country code and postcode are unambiguous and are popped from the
end; city and region are inferred from the remaining lines. The raw lines always ship in
`businessAddressLines` / `customerServiceAddressLines`, so you can re-split them yourself.

**Not every seller publishes everything.** E-mail, VAT and phone filled 29/29 here, but legal name
and address filled 26/29 and the register court only 2/29. Small sellers publish a minimum record.
Fields are emitted as `null` rather than guessed.

**The seller-profile page occasionally comes back as an empty shell** — HTTP 200, ~350 KB, but with
no profile body at all. That is a partially-served page, not a seller with no data, so the actor
detects it and skips the row instead of emitting an all-null lead. One of 30 sellers hit this in the
measured run.

**Amazon rotates the merchant link.** As recently as two days before this was built, the merchant on
a product page was found via a `/sp?…seller=` href; on today's dominant template that href does not
exist and the link is `<a id="sellerProfileTriggerId" href="/gp/help/seller/at-a-glance.html…">`.
All three resolvers ship and each row records which one fired in `sellerResolverStrategy`, so a
future change shows up as a strategy shift in your data instead of a silent zero.

**This actor does not**: scrape a seller's product catalogue (only a `catalogueSize` count), read
anything behind a login, verify e-mail deliverability, or return first-party Amazon listings (they
have no seller imprint).

**robots.txt.** `https://www.amazon.it/robots.txt` (fetched 2026-09-03) does **not** disallow any
path this actor requests under `User-agent: *`. The only near-miss rule concerns faceted search URLs
this actor never builds:

```
User-agent: *
Disallow: */s?k=*&rh=n*p_*p_*p_
```

Checked against a standard robots parser, all four request shapes — `/s?k=<keyword>`, `/dp/<ASIN>`,
`/sp?ie=UTF8&seller=<id>` and `/s?me=<id>` — are **allowed**.

**Legal / personal data — your call, not ours.** The imprint panel is published under EU trader-
transparency law, so it is public business data by design. But sole traders and small partnerships
publish a natural person's name, a home address, a personal mobile and sometimes a personal Gmail
address. Using those as B2B leads is a personal-data processing decision under GDPR, and it is
yours to make. Amazon's own Conditions of Use also restrict automated access and point commercial
users at its paid Product Advertising API; technical access is not the same as permission.

# Actor input Schema

## `marketplace` (type: `string`):

Which Amazon site to scrape. The proxy country is pinned to the marketplace automatically — Amazon serves the wrong locale (or nothing) to a mismatched exit. Measured 2026-09-03: .it, .de, .es and .nl served cleanly; .co.uk, .se and .pl needed retries; .fr is additionally behind an AWS WAF challenge and often returns nothing.

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

Keywords to search on the chosen marketplace. Every product on the results page is opened to find who sells it, then that seller's public profile is scraped. Pick keywords where marketplace sellers compete (spare parts, accessories, industrial supplies) — a big-brand keyword returns mostly Amazon's own first-party listings, which carry no seller imprint at all.

## `productUrls` (type: `array`):

Scrape the seller behind specific products. Accepts full product URLs (https://www.amazon.it/dp/B0CMY247TP) or bare ASINs (B0CMY247TP). Combine freely with keywords.

## `sellerUrls` (type: `array`):

Already know the sellers? Pass their profile URLs (…/sp?seller=A1YYMKC9INWJTB), storefront URLs (…/s?me=A1YYMKC9INWJTB) or bare seller IDs. This skips product discovery entirely — one request per lead instead of about two.

## `maxSellers` (type: `integer`):

Stop after this many unique sellers. Rows are deduplicated on seller ID, so one seller found on ten products is billed once. 0 = no limit.

## `maxPagesPerTerm` (type: `integer`):

How many pages of search results to read per keyword. One page already yields around 60 products, which is usually more than enough to fill the seller cap.

## `includeFeedbackReviews` (type: `boolean`):

Add the seller's most recent buyer feedback comments (rating, text, author, date and the seller's reply) as an array on each row. Free — it comes from the same page that is already fetched.

## `maxFeedbackReviews` (type: `integer`):

Cap the feedback array. Amazon renders about five comments on the first page of the profile.

## `includeCatalogueSize` (type: `boolean`):

Also open the seller's storefront to record how many products they list. Useful for sizing a lead, but it costs one extra page fetch per seller (roughly +45% requests) and Amazon rounds the number for large catalogues.

## `requestConcurrency` (type: `integer`):

Parallel requests. Amazon tolerates a handful; pushing this high raises the anti-bot rate and costs you retries rather than speed.

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

Residential proxy is REQUIRED. Amazon answers datacenter and home IPs with an Akamai anti-bot stub instead of the page. The default uses Apify Residential with the country pinned to the marketplace; you can plug in your own residential proxy here instead.

## Actor input object example

```json
{
  "marketplace": "amazon.it",
  "searchTerms": [
    "ricambi trattore"
  ],
  "productUrls": [],
  "sellerUrls": [],
  "maxSellers": 25,
  "maxPagesPerTerm": 1,
  "includeFeedbackReviews": true,
  "maxFeedbackReviews": 5,
  "includeCatalogueSize": false,
  "requestConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `sellers` (type: `string`):

The dataset of scraped Amazon sellers (one item per unique sellerId).

# 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": [
        "ricambi trattore"
    ],
    "maxSellers": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/amazon-seller-leads-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": ["ricambi trattore"],
    "maxSellers": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/amazon-seller-leads-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": [
    "ricambi trattore"
  ],
  "maxSellers": 25
}' |
apify call scrapersdelight/amazon-seller-leads-scraper --silent --output-dataset

```

## MCP server setup

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