# AliExpress Products Finder \[Simple to Use] (`ozer-studio/aliexpress-products-scraper`) Actor

\[UPDATED] Find and scrape AliExpress products by keyword, product URL, or reverse image search. Export product titles, prices, images, ratings, orders, store information, and listing URLs to structured JSON or CSV. Ideal for product research, price monitoring, dropshipping, and competitor analysis.

- **URL**: https://apify.com/ozer-studio/aliexpress-products-scraper.md
- **Developed by:** [Ozer Studio](https://apify.com/ozer-studio) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

## 🛍️ AliExpress Product Scraper | Keyword, URL & Reverse Image Search

The **AliExpress Product Scraper** helps you find and extract AliExpress products using **search queries, direct product URLs, or reference images**. Collect prices, discounts, ratings, sold counts, stores, product images, shipping text, variants, and source links—without needing an AliExpress API key or account.

Use it for ecommerce research, dropshipping, sourcing, catalog building, product monitoring, competitive analysis, spreadsheets, APIs, and AI-agent workflows.

### 📋 What This Scraper Does

The Actor searches public AliExpress pages and returns structured product data, including:

- 🔍 **Keyword search** — Search one or multiple product queries in a single run
- 🖼️ **Reverse image search** — Upload product photos or submit public image URLs
- 🔗 **Direct URL scraping** — Extract product data from a list of AliExpress links
- 💰 **Pricing data** — Displayed price, original price, currency, and discount percentage
- ⭐ **Demand signals** — Rating, review count, and sold count when displayed
- 🏪 **Store information** — Store name, store URL, store ID, and availability when available
- 🎨 **Product details** — Additional images and option groups with optional enrichment
- 📥 **Flexible exports** — Apify dataset plus combined or separate CSV files

### 🔧 Problem Solved

AliExpress product research can be slow when you need to repeat searches, compare dozens of listings, or locate a product from only a photo. This Actor turns those manual steps into reusable structured data.

It is useful for:

- 📦 **Product sourcing** — Discover products and stores from keywords or reference images
- 🛒 **Ecommerce research** — Review prices, discounts, ratings, and sales signals
- 🔎 **Competitor research** — Find similar products using reverse image search
- 📊 **Market analysis** — Build datasets for spreadsheets, dashboards, and reports
- 🔄 **Catalog enrichment** — Add current public data to known AliExpress product URLs
- 🤖 **Automation** — Connect AliExpress search results to APIs, MCP clients, and AI agents

### ⚡ Features

| Feature | Description |
| --- | --- |
| 🔍 Multiple Search Queries | Search up to 20 product queries in one run |
| 🖼️ Batch Reverse Image Search | Search uploaded images and public image URLs separately |
| 🔗 Direct `productUrls` Input | Scrape up to 100 AliExpress product links directly |
| 📄 Pagination | Process up to 60 keyword pages or 5 image-result pages per input |
| 🎯 Per-Input Limits | Every query and image receives its own product target |
| 🧹 Product Deduplication | One row per unique product while preserving all matching inputs |
| 💰 Normalized Pricing | Displayed and numeric prices, original price, currency, and discount |
| ⭐ Demand Signals | Rating, review count, and sold count when AliExpress displays them |
| 🏪 Optional Enrichment | Visit product pages for store data, images, availability, and options |
| 📥 CSV & Dataset Output | Combined CSV, separate files per input, or both |
| 🌐 Proxy Support | Works with Apify Proxy for more reliable browser requests |
| 🧰 Failure Diagnostics | Saves debug HTML and screenshots for failed searches |
| 🤖 API & MCP Ready | Structured input and output for automation and AI tools |

### 🧭 Search Modes

#### 🔍 Keyword Search

Use product names or keywords when you know what you want to find. Each search query is processed independently.

Examples:

- `wireless earbuds`
- `portable blender`
- `stainless steel shower hinge`

#### 🖼️ Reverse Image Search

Use a reference image when the product name is unknown or visual similarity matters. You can:

- Upload images directly in Apify Console
- Provide public image URLs through the input form
- Send image URLs from the API or an MCP client
- Search up to 20 images in one run

Every image has a separate product limit, so results from the first image do not stop later searches.

#### 🔗 Direct Product URLs

Use `productUrls` to scrape known AliExpress listings directly. This mode automatically visits each product page for available details.

If an API client provides `productUrls` without Search Queries, the Actor automatically uses direct URL mode even if `searchMode` is omitted.

### 🎛️ Input Parameters

| Parameter | Type | Default | Maximum | Description |
| --- | --- | --- | ---: | --- |
| `searchMode` | string | `keyword` | — | `keyword`, `image`, or `urls` |
| `searchTerms` | array | `["monitors"]` | 20 | Product Search Queries processed separately; replace the preset with your own query |
| `productUrls` | array | `[]` | 100 | AliExpress product URLs to scrape directly; required when Search Queries are not provided |
| `maxProductsPerKeyword` | integer | `50` | 1,000 | Unique products retained separately for each query |
| `maxPagesText` | integer | `1` | 60 | Result pages processed separately for each query |
| `uploadedImages` | array | `[]` | 20 combined | Images uploaded through Apify Console |
| `imageUrls` | array | `[]` | 20 combined | Public HTTP or HTTPS product image URLs |
| `maxProductsPerImage` | integer | `20` | 300 | Unique products retained separately for each image |
| `maxPagesImage` | integer | `1` | 5 | Image-result pages processed separately for each image |
| `skipFailedImages` | boolean | `true` | — | Continue when one image cannot be downloaded, uploaded, or searched |
| `includeProductDetails` | boolean | `false` | — | Visit accepted product pages after keyword or image search |
| `useApifyProxy` | boolean | `true` | — | Route browser requests through Apify Proxy |
| `failOnNoResults` | boolean | `false` | — | Fail the run instead of finishing with a warning when no products are found |
| `saveCsvFile` | boolean | `true` | — | Save CSV files in the default key-value store |
| `csvOutputMode` | string | `combined` | — | `combined`, `separate`, or `both` |
| `csvFilename` | string | `aliexpress_products.csv` | — | Filename for the combined CSV export |

### 📝 Example Inputs

#### 🔍 Search Multiple Queries

```json
{
  "searchMode": "keyword",
  "searchTerms": [
    "wireless earbuds",
    "portable blender",
    "mini projector"
  ],
  "maxProductsPerKeyword": 50,
  "maxPagesText": 2,
  "includeProductDetails": false,
  "useApifyProxy": true,
  "saveCsvFile": true,
  "csvOutputMode": "combined"
}
```

💡 With three Search Queries and a limit of 50 products per query, the run can return up to 150 input matches before cross-query deduplication.

#### 🖼️ Search Multiple Product Images

```json
{
  "searchMode": "image",
  "imageUrls": [
    "https://example.com/reference-product-1.jpg",
    "https://example.com/reference-product-2.jpg"
  ],
  "maxProductsPerImage": 20,
  "maxPagesImage": 1,
  "skipFailedImages": true,
  "useApifyProxy": true,
  "saveCsvFile": true,
  "csvOutputMode": "separate"
}
```

In Apify Console, use **Product images** to upload local files instead of `imageUrls`.

#### 🔗 Scrape Direct Product URLs

```json
{
  "searchMode": "urls",
  "productUrls": [
    "https://www.aliexpress.com/item/1005001234567890.html",
    "https://www.aliexpress.com/item/1005009876543210.html"
  ],
  "useApifyProxy": true,
  "saveCsvFile": true
}
```

### 📤 Output Data Structure

Each dataset row represents one unique AliExpress product. If different queries or images find the same product, `matched_search_inputs` preserves every matching input.

#### 🛍️ Core Product Fields

| Field | Type | Description |
| --- | --- | --- |
| `product_id` | string or null | AliExpress product identifier |
| `title` | string | Product title displayed by AliExpress |
| `product_url` | string | Canonical AliExpress product link |
| `source_url` | string or null | Original result link before URL normalization |
| `image_url` | string or null | Primary product image |
| `image_urls` | array | Additional product images when available |

#### 💰 Pricing Fields

| Field | Type | Description |
| --- | --- | --- |
| `price` | string | Price exactly as displayed |
| `price_value` | number or null | Normalized numeric price |
| `original_price` | string or null | Original or crossed-out displayed price |
| `original_price_value` | number or null | Normalized original price |
| `currency` | string or null | Inferred ISO currency code |
| `discount_percent` | integer or null | Displayed percentage discount |

#### ⭐ Demand & Store Fields

| Field | Type | Description |
| --- | --- | --- |
| `rating` | number or null | Displayed product rating |
| `review_count` | integer or null | Displayed review or rating count |
| `sold_count` | integer or null | Normalized displayed sold count |
| `store_name` | string or null | Public AliExpress store name |
| `store_url` | string or null | Public store link |
| `store_id` | string or null | Store identifier when available |
| `shipping` | string or null | Shipping or delivery text shown in results |
| `availability` | string or null | Availability from the product page when available |
| `options` | array | Product option groups collected during enrichment |

#### 🏷️ Search Metadata

| Field | Type | Description |
| --- | --- | --- |
| `search_input` | string | First Search Query, image filename, or URL that found the product |
| `search_type` | string | `keyword`, `image`, or `url` |
| `matched_search_inputs` | array | Every input that matched the product |
| `match_rank` | integer or null | One-based result position for the first match |
| `result_page` | integer or null | Search-result page where the match appeared |
| `detail_enriched` | boolean | Whether the product page was visited successfully |
| `scraped_at` | string or null | ISO 8601 extraction timestamp |

### 📄 Example Output

```json
{
  "search_input": "wireless earbuds",
  "search_type": "keyword",
  "matched_search_inputs": [
    "wireless earbuds",
    "earbuds-reference.jpg"
  ],
  "product_id": "1005001234567890",
  "title": "Wireless Bluetooth Earbuds with Charging Case",
  "product_url": "https://www.aliexpress.com/item/1005001234567890.html",
  "image_url": "https://ae01.alicdn.com/kf/example.jpg",
  "image_urls": [
    "https://ae01.alicdn.com/kf/example.jpg"
  ],
  "price": "US $12.99",
  "price_value": 12.99,
  "original_price": "US $24.99",
  "original_price_value": 24.99,
  "currency": "USD",
  "discount_percent": 48,
  "rating": 4.7,
  "review_count": 832,
  "sold_count": 5000,
  "store_name": "Example Audio Store",
  "store_url": "https://www.aliexpress.com/store/1234567",
  "shipping": "Free shipping",
  "match_rank": 1,
  "result_page": 1,
  "detail_enriched": false,
  "scraped_at": "2026-08-26T12:00:00+00:00"
}
```

💡 Prices, shipping, availability, and discounts may vary by delivery country, selected currency, account state, and time. The Actor returns what AliExpress displays during the run.

### 📥 Export Options

#### 🗂️ Apify Dataset

The default dataset is always available and can be downloaded through Apify as:

- JSON
- CSV
- Excel
- XML
- RSS
- HTML table

#### 📄 Named CSV Files

When `saveCsvFile` is enabled, the Actor stores CSV files in the default key-value store:

- `combined` — One file using `csvFilename`
- `separate` — One CSV for each Search Query, image, or product URL
- `both` — Combined and separate files

The key-value store also contains `RUN_SUMMARY.json` and any failure diagnostics.

### 🚀 Getting Started

#### ☁️ Run on Apify Cloud

1. Open the Actor in Apify Console. The default keyword run searches for **monitors**, so the Actor can be tested immediately.
2. Replace **monitors** with your own query, or choose **Reverse image search** or **Direct product URLs**.
3. Add the matching queries, images, or links.
4. Set the per-input product and page limits.
5. Keep **Use Apify Proxy** enabled for better reliability.
6. Click **Start**.
7. Download results from **Dataset** or CSV files from **Key-value store**.

For runs without a platform time cutoff, open the Actor's **Settings → Run options**, set **Timeout** to `0` (**No timeout**), and enable **No maximum limit** for maximum cost per run. These are Apify Actor settings rather than JSON input fields. Reverse image search and product-page enrichment take longer than listing-only keyword runs.

### 🔌 Run with the Apify API

Replace `<APIFY_TOKEN>` with your Apify token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/toolsnmoreapi~AliExpress-Products-Scraper/runs?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "searchMode": "keyword",
    "searchTerms": ["portable projector"],
    "maxProductsPerKeyword": 50,
    "useApifyProxy": true
  }'
```

Apify API paths use `username~actor-name`. If the Actor's final technical name differs, copy the generated endpoint from the Actor's **API** tab.

### 🤖 Use with MCP & AI Agents

Load this Actor as a tool through Apify's hosted MCP server:

```text
https://mcp.apify.com?tools=toolsnmoreapi/AliExpress-Products-Scraper
```

Authenticate the MCP client with Apify before running Actors or reading private storage.

Example prompts:

> 🔍 Search AliExpress for portable projectors. Return 50 products with price, rating, sold count, and product URL.

> 🖼️ Reverse-search these three public product image URLs. Return 20 matches per image and save separate CSV files.

> 🔗 Extract the latest public product data from these AliExpress URLs and compare their prices and sales signals.

### 💡 Use Cases

| Use case | How the Actor helps |
| --- | --- |
| 🛒 Ecommerce Research | Discover products and compare visible market signals |
| 📦 Dropshipping Research | Find possible products, stores, and pricing ranges |
| 🖼️ Visual Product Matching | Search for similar products from reference images |
| 💰 Price Monitoring | Repeat saved tasks and compare results over time |
| 🔎 Competitive Research | Locate related listings and review visible demand signals |
| 📋 Catalog Building | Export product links, images, prices, and store information |
| 📊 Data Analysis | Create structured datasets for reporting and BI workflows |
| 🤖 AI Agents | Give agents current AliExpress product data through MCP or API |

### 🆚 Why This Actor Is Different

| Capability | This Actor | Basic keyword-only scraper |
| --- | :---: | :---: |
| 🔍 Multiple Search Queries | ✅ | ✅ |
| 🖼️ Reverse Image Search | ✅ | ❌ |
| 🔗 Direct Product URLs | ✅ | Sometimes |
| 🎯 Separate Limit Per Query/Image | ✅ | Often global only |
| 🧹 Cross-Input Deduplication | ✅ | Varies |
| 🏷️ Matching Input Attribution | ✅ | Varies |
| 📄 Separate CSV Per Input | ✅ | Rarely |
| 🤖 MCP-Friendly Inputs | ✅ | Varies |

### ❓ Frequently Asked Questions

#### 🔑 Do I need an AliExpress API key or account?

No. The Actor reads publicly displayed AliExpress pages. You need an Apify account to run the Actor on Apify Cloud, and API/MCP clients need Apify authentication.

#### 🖼️ Can I search more than one image?

Yes. Add up to 20 uploaded images and public image URLs combined. Each image is searched independently and receives its own `maxProductsPerImage` limit.

#### 🔗 Can I scrape a list of known product links?

Yes. Add the links to `productUrls` and choose Direct product URLs. If an API caller supplies only `productUrls`, the Actor automatically uses direct URL mode.

Use direct item links containing `/item/...html`. An AliExpress search-results URL belongs in neither `productUrls` nor `imageUrls`; copy its search phrase into `searchTerms` instead.

#### 🎯 Why are there fewer rows than all per-input limits added together?

The Actor deduplicates identical product IDs across inputs. The final row keeps every matching input in `matched_search_inputs`.

#### 🏪 Why are some store or option fields empty?

Search cards do not always show those values. Enable `includeProductDetails` to visit accepted product pages and collect additional public fields when available.

#### ⏱️ Why does detail enrichment take longer?

The Actor must open one extra product page for every accepted result. Leave enrichment disabled for fast listing-only research, or raise the Apify run timeout for larger enriched batches.

#### 🌐 Should I enable Apify Proxy?

Yes. It is enabled by default and recommended, especially for multi-page and reverse-image runs. AliExpress can still present verification pages occasionally.

#### 📥 Where is my CSV file?

Open the run's **Storage → Key-value store**. The structured dataset is available separately under **Storage → Dataset**.

### ⚠️ Reliability Notes

- AliExpress can change page layouts, experiments, prices, and availability without notice.
- Verification pages can occur even when proxying is enabled.
- When possible, successful inputs are retained and diagnostics are saved for failed ones.
- Public image URLs must point to actual image files on public internet addresses.
- Product-page enrichment increases runtime and browser usage.

### ✅ Responsible Use

Scrape only publicly available information and follow applicable laws, AliExpress terms, and Apify platform rules. Do not use this Actor to collect private, restricted, or personal data.

### 🆘 Support

If a run fails or AliExpress changes its page layout, provide:

- The Apify run ID
- Input with secrets removed
- Relevant log lines
- The saved debug HTML or screenshot key, when available

This is usually enough to reproduce and fix the issue quickly.

# Actor input Schema

## `searchMode` (type: `string`):

Choose how products should be found. Keyword search uses Search Queries, Reverse image search uses uploaded files or direct image URLs, and Direct product URLs uses productUrls.

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

Product names or keywords to search on AliExpress. The preset query is monitors, which you can replace with your own search. Required when Search mode is Keyword search unless productUrls is provided.

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

Direct AliExpress item links containing /item/...html. Do not paste an AliExpress search-results page here; use Search Queries for that. Required when Search Queries are not provided. JSON field name: productUrls.

## `maxProductsPerKeyword` (type: `integer`):

Maximum unique products collected separately for each keyword, not for the whole run.

## `maxPagesText` (type: `integer`):

Maximum AliExpress pages processed separately for each keyword. The Actor stops sooner when the product target is reached.

## `uploadedImages` (type: `array`):

Used only in Reverse image search. Upload up to 20 JPG, PNG, WebP, GIF, or BMP images. Each image is searched separately. For API or MCP use, add public URLs below.

## `imageUrls` (type: `array`):

Direct, publicly accessible HTTP or HTTPS image-file URLs. AliExpress search pages and product pages are not images. Recommended for API and MCP clients.

## `maxProductsPerImage` (type: `integer`):

Maximum unique products collected separately for each image, not for the whole batch.

## `maxPagesImage` (type: `integer`):

Maximum image-result pages processed separately for each image. AliExpress currently exposes up to five pages in image search.

## `skipFailedImages` (type: `boolean`):

Continue with the remaining images when one cannot be downloaded, uploaded, or searched. Disable to fail immediately.

## `useApifyProxy` (type: `boolean`):

Recommended because AliExpress may challenge direct datacenter traffic, especially during multi-page or multi-image runs.

## `includeProductDetails` (type: `boolean`):

After a keyword or image search, visit every accepted product page to add store information, more images, availability, and option groups. Slower than listing-only mode. Direct product URL mode always visits product pages.

## `failOnNoResults` (type: `boolean`):

Enable for automations that should fail when the entire run produces no usable product rows. Leave disabled to finish with a warning and save diagnostics.

## `saveCsvFile` (type: `boolean`):

Save a named CSV in the run's key-value store in addition to the structured Apify dataset.

## `csvOutputMode` (type: `string`):

Choose one combined file, one file per search query/image/URL, or both. Used only when Save CSV file is enabled.

## `csvFilename` (type: `string`):

Filename used when Save CSV file is enabled.

## Actor input object example

```json
{
  "searchMode": "keyword",
  "searchTerms": [
    "monitors"
  ],
  "productUrls": [],
  "maxProductsPerKeyword": 50,
  "maxPagesText": 1,
  "uploadedImages": [],
  "imageUrls": [],
  "maxProductsPerImage": 20,
  "maxPagesImage": 1,
  "skipFailedImages": true,
  "useApifyProxy": true,
  "includeProductDetails": false,
  "failOnNoResults": false,
  "saveCsvFile": true,
  "csvOutputMode": "combined",
  "csvFilename": "aliexpress_products.csv"
}
```

# Actor output Schema

## `results` (type: `string`):

Unique AliExpress products with search attribution, prices, demand signals, stores, images, and optional product-page details.

## `files` (type: `string`):

The optional CSV export, RUN\_SUMMARY.json, and any debug HTML or screenshots saved for failed inputs.

# 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": [
        "monitors"
    ],
    "productUrls": [],
    "uploadedImages": [],
    "imageUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("ozer-studio/aliexpress-products-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": ["monitors"],
    "productUrls": [],
    "uploadedImages": [],
    "imageUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("ozer-studio/aliexpress-products-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": [
    "monitors"
  ],
  "productUrls": [],
  "uploadedImages": [],
  "imageUrls": []
}' |
apify call ozer-studio/aliexpress-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ozer-studio/aliexpress-products-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/aDZ8xP5MzgAHCHg0V/builds/b5b65s0CoQbySDih3/openapi.json