# AliExpress Products & Seller Catalog Scraper (`automation-lab/aliexpress-products-scraper`) Actor

Extract AliExpress product searches, full item details, prices, variants, seller data, and public store catalogs for supplier sourcing and monitoring.

- **URL**: https://apify.com/automation-lab/aliexpress-products-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 3 total users, 2 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/platform/actors/running/actors-in-store#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 Products & Seller Catalog Scraper

Extract **AliExpress product search details and seller catalogs** for supplier sourcing, assortment research, and recurring price monitoring.

This Actor turns public AliExpress searches, item URLs, and store URLs into typed product records. It captures prices, discounts, ratings, sales counts, images, stock, variants, specifications, and public seller context where the selected route provides them.

### What can this AliExpress scraper do?

- Search AliExpress by one or more buyer keywords.
- Extract canonical product IDs, titles, URLs, images, and displayed prices.
- Capture ratings, sold counts, discounts, and currency when shown.
- Resolve explicit item URLs to core product snapshots and retain structured product-detail data when AliExpress exposes it.
- Extract stock, specifications, variants, category, and seller identity when present in the structured response.
- Snapshot products displayed in a public seller catalog.
- Add store name, store ID, followers, and positive-feedback rate where available.
- Deduplicate products across all inputs in one run.
- Stop at a user-controlled global product limit.
- Rotate challenged sticky datacenter sessions up to twice, then fail loudly rather than spend on an ineffective route.

The Actor does not require an AliExpress account, cookies, or an external API key.

### Who is it for?

#### Supplier sourcing teams

Compare products from keyword searches and inspect the public store behind a promising item.

#### Marketplace analysts

Collect consistent product rows for price, discount, rating, and assortment comparisons.

#### Dropshipping operators

Resolve item URLs to stable product identity and inspect any variants, stock, specifications, and public seller signals AliExpress exposes before shortlisting products.

#### Data and automation teams

Schedule the same search or seller input and compare dataset snapshots in a warehouse, spreadsheet, or monitoring workflow.

#### Developers

Call the Actor through the Apify API, JavaScript client, Python client, or MCP.

### Why use this Actor?

AliExpress serves different parts of the product journey through different browser and structured-data surfaces. A simple HTML request can return a CAPTCHA, an empty client-rendered shell, or incomplete product cards.

This Actor combines:

1. rendered product search pages;
2. AliExpress's signed in-browser product-detail response;
3. the mobile public store surface for seller product discovery;
4. sticky browser, cookie, locale, and proxy sessions;
5. up to two bounded datacenter session rotations after verified blocking.

Challenge pages are treated as errors, not as valid empty results.

### What data does it extract?

| Field | Meaning |
|---|---|
| `sourceType` | `search`, `product_detail`, or `seller_catalog` |
| `productId` | AliExpress product identifier |
| `title` | Product title |
| `url` | Canonical AliExpress product URL |
| `imageUrl` | Primary image URL when available |
| `currentPrice` | Current displayed or selected price |
| `originalPrice` | Pre-discount price when available |
| `currency` | Localized currency code |
| `discountPercentage` | Displayed or calculated discount |
| `rating` | Product rating |
| `orders` | Displayed sold/order count |
| `availability` | Normalized detail availability |
| `stock` | Available inventory from product detail |
| `categoryId` | AliExpress category ID |
| `sellerId` | Public seller ID |
| `storeId` | Public store ID |
| `storeName` | Store display name |
| `storeUrl` | Public store URL |
| `sellerPositiveRate` | Positive-feedback percentage |
| `sellerFollowers` | Displayed follower count |
| `properties` | Product specification name/value pairs |
| `variants` | Structured SKU price/stock entries |
| `searchQuery` | Query that found a search record |
| `sellerCatalogUrl` | Store input that found a catalog record |
| `scrapedAt` | Extraction time in ISO 8601 format |

Fields can be `null` when AliExpress does not expose them on that route or for that product.

### Getting started

1. Open the Actor input page.
2. Add at least one search query, product URL, or seller URL.
3. Set `maxItems` to the number of unique product rows you need.
4. Keep `maxPagesPerQuery` small for a test run.
5. Start the run.
6. Open the **Products** dataset view.
7. Export the data as JSON, CSV, Excel, or another Apify-supported format.

A useful first input is:

```json
{
  "searchQueries": ["wireless earbuds"],
  "maxItems": 5,
  "maxPagesPerQuery": 1
}
```

### Input parameters

#### `searchQueries`

An array of product keywords, for example `wireless earbuds` or `camping cookware`.

#### `productUrls`

AliExpress URLs containing `/item/<id>.html`. These produce detailed records with specifications, stock, variants, and seller data when available.

#### `sellerUrls`

Public AliExpress URLs containing `/store/<id>`. These produce product rows from the store's public catalog surface.

#### `maxItems`

Global number of unique products saved across all inputs. Range: 1–1,000. Default: 50.

#### `maxPagesPerQuery`

Maximum discovery depth for each search or seller input. Range: 1–20. Default: 3.

### Search workflow example

Find five wireless earbud listings:

```json
{
  "searchQueries": ["wireless earbuds"],
  "maxItems": 5,
  "maxPagesPerQuery": 1
}
```

Search rows prioritize comparable listing fields such as title, current price, image, discount, rating, and sold count.

### Product-detail workflow example

Inspect one current item:

```json
{
  "productUrls": [
    { "url": "https://www.aliexpress.com/item/3256812072210872.html" }
  ],
  "maxItems": 1
}
```

The Actor keeps the same browser session while AliExpress bootstraps its anonymous token and returns structured detail data.

### Seller-catalog workflow example

Capture a supplier assortment snapshot:

```json
{
  "sellerUrls": [
    { "url": "https://www.aliexpress.com/store/1103576287" }
  ],
  "maxItems": 10,
  "maxPagesPerQuery": 1
}
```

Schedule this input and compare product IDs, titles, and prices between runs in your own downstream system.

The Actor emits the current snapshot; it does not itself store history or send alerts.

### Output example

A current detailed record has this shape:

```json
{
  "entityType": "product",
  "sourceType": "product_detail",
  "productId": "3256812072210872",
  "title": "Xiaomi Airdots 2 Wireless Earphones Bluetooth Headset",
  "url": "https://www.aliexpress.com/item/3256812072210872.html",
  "imageUrl": "https://ae-pic-a1.aliexpress-media.com/kf/sample.jpg",
  "currentPrice": 7.2,
  "originalPrice": 14.41,
  "currency": "USD",
  "discountPercentage": 50,
  "rating": 4.9,
  "availability": "in_stock",
  "stock": 64,
  "categoryId": "63705",
  "sellerId": "2678280160",
  "storeId": "1103576287",
  "storeName": "Stone's Store",
  "storeUrl": "https://www.aliexpress.com/store/1103576287",
  "sellerPositiveRate": 100,
  "properties": [
    { "name": "Bluetooth Version", "value": "5.0" }
  ],
  "variants": [],
  "searchQuery": null,
  "sellerCatalogUrl": null,
  "scrapedAt": "2026-07-28T18:02:26.641Z"
}
```

Values and availability change over time. Treat the example as a field guide, not a price guarantee.

### How much does it cost to scrape AliExpress products?

The Actor uses pay per event pricing:

- **Start:** $0.010 once per run.
- **Product:** one `item` event for each unique product record saved.
- No charge is emitted for rejected, duplicate, challenged, or failed records.

Current per-product tiers are:

| Plan tier | Price per product |
|---|---:|
| Free | $0.020240 |
| Bronze | $0.017600 |
| Silver | $0.013728 |
| Gold | $0.010560 |
| Platinum | $0.007040 |
| Diamond | $0.004928 |

At Bronze pricing, excluding variable platform usage where applicable:

- 5 products: `$0.010 + (5 × $0.017600)`.
- 25 products: `$0.010 + (25 × $0.017600)`.
- 100 products: `$0.010 + (100 × $0.017600)`.

AliExpress protection can affect runtime and proxy transfer, but it does not create extra Actor event types.

### Recurring price and catalog monitoring

A repeatable monitoring workflow is:

1. Save a Task with stable queries, item URLs, or seller URLs.
2. Schedule it daily or weekly.
3. Export each default dataset to your storage system.
4. Join rows by `productId`.
5. Compare non-null `currentPrice`, `originalPrice`, `stock`, and store fields.
6. Trigger your own notifications for meaningful changes.

Use explicit product URLs to request deeper stock and specification fields, while treating those fields as optional because AliExpress can withhold its structured response. Use searches or seller catalogs for wider assortment discovery.

### Export and integrations

The default dataset works with:

- JSON and JSONL exports;
- CSV and Excel exports;
- Google Sheets integrations;
- webhooks and automation platforms;
- Apify dataset API clients;
- data warehouses and BI pipelines.

Every run uses its own default dataset, so results do not leak from previous runs.

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~aliexpress-products-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["wireless earbuds"],
    "maxItems": 5,
    "maxPagesPerQuery": 1
  }'
```

Keep your token in an environment variable or secret manager.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/aliexpress-products-scraper').call({
  sellerUrls: [{ url: 'https://www.aliexpress.com/store/1103576287' }],
  maxItems: 10,
  maxPagesPerQuery: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/aliexpress-products-scraper").call(
    run_input={
        "productUrls": [
            {"url": "https://www.aliexpress.com/item/3256812072210872.html"}
        ],
        "maxItems": 1,
    }
)

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP

Add this Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/aliexpress-products-scraper"
```

#### Claude Desktop

Add the following remote MCP server in Claude Desktop:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/aliexpress-products-scraper"
    }
  }
}
```

#### Cursor

Use the same JSON in Cursor's MCP settings and enable the `apify` server.

#### VS Code

Add the same HTTP MCP server URL to your VS Code MCP configuration.

Example prompts:

- “Find five AliExpress wireless earbud products and compare prices.”
- “Extract the current detail record for this AliExpress item URL.”
- “Capture ten products from this public AliExpress seller store.”

### Reliability and anti-bot behavior

AliExpress can vary responses by session, country, source route, and request history.

The Actor:

- keeps proxy identity and cookies together;
- reuses healthy sessions;
- detects CAPTCHA and punish pages;
- rotates challenged datacenter sessions up to twice;
- avoids automatic residential fallback after measured validation showed it added cost without useful output;
- retries transient browser navigation changes;
- fails loudly after bounded escalation.

A failed source is not converted into a successful run with zero expected rows.

### Limits and responsible scaling

- Keep initial runs small.
- Increase `maxItems` and page depth gradually.
- Search and seller pages can reorder products between runs.
- Localized prices can differ by destination, session, promotion, and currency.
- Some product IDs redirect between AliExpress country domains.
- Seller catalog rows contain the fields visible on the store surface; use explicit product URLs for deeper enrichment.
- Products can disappear or become unavailable by region.
- AliExpress sometimes withholds its structured detail response while still rendering a useful public product page. In that case, the Actor saves core item fields and leaves unavailable stock, specification, and variant fields null or empty.
- The Actor does not bypass login-only or private information.

### Troubleshooting

#### “Provide at least one search query, product URL, or seller URL”

Add a supported value to `searchQueries`, `productUrls`, or `sellerUrls`.

#### “Product URL does not contain /item/<id>.html”

Use a normal public AliExpress item URL rather than a shortened or unrelated URL.

#### “Seller URL does not contain /store/<id>”

Open the seller's public store and copy its numeric `/store/` URL.

#### “AliExpress listing failed after bounded proxy/session escalation”

The source returned challenges or empty shells across all three bounded datacenter sessions. Retry later or reduce parallel scheduled activity.

#### Why are some fields null?

Search cards, item details, and seller catalogs expose different fields. Null means the source did not provide that value on the selected route.

### Legal and responsible use

This Actor extracts publicly accessible marketplace information.

You are responsible for:

- complying with AliExpress terms and applicable law;
- using data for a lawful purpose;
- respecting intellectual property and database rights;
- avoiding personal-data profiling or harmful surveillance;
- choosing a reasonable schedule and volume;
- securing exported datasets and API tokens.

Do not use the Actor to access private accounts, evade access controls, or collect information you are not authorized to process.

### FAQ

#### Does it require an AliExpress login?

No. The implemented workflows use anonymous public surfaces.

#### Can it scrape both `.com` and `.us` item URLs?

Yes. Supported product URLs use `aliexpress.com` or `aliexpress.us` and contain a numeric item path.

#### Does it enrich every search and catalog row automatically?

No. Search and catalog modes preserve efficient listing-level records. Item URLs request deeper specifications, stock, variants, and seller detail, but those optional fields remain null or empty when AliExpress withholds its structured response.

#### Does it store historical prices?

No. Each run returns a current snapshot. Store and compare snapshots in your own system.

#### Why did a product redirect to another AliExpress domain?

AliExpress localizes pages by session and country. The Actor captures the structured product response and emits a stable canonical `.com` product URL.

### Related Automation Lab Actors

- [DHgate Product & Supplier Scraper](https://apify.com/automation-lab/dhgate-product-supplier-scraper) for another cross-border marketplace.
- [Alibaba Supplier Scraper](https://apify.com/automation-lab/alibaba-supplier-scraper) for supplier discovery on Alibaba.
- [1688 Scraper](https://apify.com/automation-lab/1688-scraper) for Chinese wholesale product research.

Choose this Actor when your source of record is public AliExpress product or seller-store data.

### Support

If a previously working input fails consistently, include:

- the input mode;
- a redacted example URL or query;
- the run ID;
- the error message.

Do not include Apify tokens, private cookies, or account credentials.

# Actor input Schema

## `searchQueries` (type: `array`):

AliExpress product searches to run, such as wireless earbuds or camping cookware.

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

Specific public AliExpress item URLs to enrich with product, price, variant, stock, and seller details.

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

Public AliExpress /store/<id> URLs whose product catalogs should be extracted.

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

Maximum unique product records saved across all searches and URLs.

## `maxPagesPerQuery` (type: `integer`):

Maximum result pages visited for each search query or seller catalog.

## Actor input object example

```json
{
  "searchQueries": [
    "wireless earbuds"
  ],
  "productUrls": [],
  "sellerUrls": [],
  "maxItems": 10,
  "maxPagesPerQuery": 1
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing all extracted AliExpress product records.

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

Table view of the most useful product and seller fields.

# 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 = {
    "searchQueries": [
        "wireless earbuds"
    ],
    "productUrls": [],
    "sellerUrls": [],
    "maxItems": 10,
    "maxPagesPerQuery": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "searchQueries": ["wireless earbuds"],
    "productUrls": [],
    "sellerUrls": [],
    "maxItems": 10,
    "maxPagesPerQuery": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/aliexpress-products-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "wireless earbuds"
  ],
  "productUrls": [],
  "sellerUrls": [],
  "maxItems": 10,
  "maxPagesPerQuery": 1
}' |
apify call automation-lab/aliexpress-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/aliexpress-products-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/jidXF4cs22JvAjKlv/builds/iK0bdiNQpljtXNSFP/openapi.json