# AliExpress Scraper - Product Search, Prices & Sold Counts (`datagleaner/aliexpress-scraper`) Actor

AliExpress scraper for product search by keyword: title, price, original price and discount, units sold, rating, images, promotions and delivery estimate. Plain HTTP, no browser, no login. $2 per 1,000 products.

- **URL**: https://apify.com/datagleaner/aliexpress-scraper.md
- **Developed by:** [Data Gleaner](https://apify.com/datagleaner) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 aliexpress products

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?

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

## AliExpress Scraper - Product Search, Prices & Sold Counts by Keyword

Scrape AliExpress search results for any keyword: title, price, original price and discount, units sold, rating, images, promotion and delivery estimate, as one clean JSON record per product. Sort by orders (best sellers first), price or best match, and filter by price range.

It reads the public AliExpress search pages over plain HTTP, with no browser, no login and no AliExpress account, and costs **$2 per 1,000 products**.

**Search only.** This Actor returns what AliExpress shows on its search result cards. It does not open product pages: those load their price, store and review data in the browser through signed requests that this Actor does not use, so a product URL or ID cannot be looked up (see Limits).

### What does AliExpress Scraper do?

It returns the data a shopper sees in the AliExpress search grid, through the Apify dataset and API as JSON, CSV or Excel. Typical uses:

- **Dropshipping and product research:** list the best sellers for a keyword by units sold, with price and rating.
- **Price monitoring:** schedule the same keyword daily and compare `price` and `discountPercent` between runs.
- **Competitor and market mapping:** see what a niche sells for, how discounted it is and how many units move.
- **Catalog seeding:** titles, image URLs and category IDs for a product feed.
- **AI agents and shopping tools:** feed live AliExpress results into an LLM agent or a deal finder.

### Input

| Field | Meaning |
|---|---|
| `keywords` | Search terms as you would type them: `phone case`, `led strip light`. Each returns up to `maxItems` products. |
| `searchUrls` | Optional AliExpress search URLs, e.g. `https://www.aliexpress.com/wholesale?SearchText=phone+case&SortType=price_asc`. The keyword, sort and price range in the URL are used. Product page URLs are not supported. |
| `sortBy` | `orders` (default, best sellers first), `bestMatch`, `priceAsc`, `priceDesc`. |
| `maxItems` | Products per keyword, default 60, max 1,000. AliExpress returns 60 products per result page. |
| `minPrice`, `maxPrice` | Price range in USD. |
| `requestDelaySecs` | Pacing between result pages, default 1. |
| `proxyConfiguration` | Apify datacenter proxy by default. |

With no input at all, the Actor runs a built-in example of 5 products for "phone case". If you already call another AliExpress Actor, these input names are also accepted: `queries`, `searchTerms`, `startUrls`, `maxProducts`, `maxResults`, `sort`.

```json
{
  "keywords": ["phone case", "led strip light"],
  "sortBy": "orders",
  "maxItems": 60
}
```

### Output

```json
{
  "id": "3256808722668670",
  "url": "https://www.aliexpress.com/item/3256808722668670.html",
  "title": "Luxury Magnetic Matte Translucent Armor Shockproof Case For iPhone 11 12 13 14 15 16 For Magsafe Wireless Charge Cover",
  "price": 0.33,
  "currency": "USD",
  "priceSource": "card",
  "priceDisplay": "US $0.33",
  "originalPrice": 5.93,
  "discountPercent": 94,
  "sold": 100000,
  "soldDisplay": "100K+ sold",
  "tradeCount": 153730,
  "rating": 4.9,
  "isChoice": true,
  "promotion": "Dollar Express",
  "tags": ["Delivery: Oct 17 - 23"],
  "deliveryEstimate": "Oct 17 - 23",
  "imageUrl": "https://ae-pic-a1.aliexpress-media.com/kf/S6f0638ad548548fb92bb7f3a1d486687g.jpg",
  "images": ["https://ae-pic-a1.aliexpress-media.com/kf/S6f0638ad548548fb92bb7f3a1d486687g.jpg", "..."],
  "categoryIds": ["202192403", "202228401", "380230"],
  "skuId": "12000060955015537",
  "position": 1,
  "page": 1,
  "keyword": "phone case",
  "sortBy": "orders",
  "source": "search",
  "scrapedAt": "2026-10-12T00:00:00Z"
}
```

`position` is the product's 1-based rank for that keyword and sort order. The dataset has a **Products** view with the main columns.

#### Which fields are filled

In a platform test of 60 products for "phone case" (sorted by orders):

- **Always filled:** `id`, `url`, `title`, `price`, `currency`, `sold`, `soldDisplay`, `tradeCount`, `rating`, `isChoice`, `imageUrl`, `images`, `categoryIds`, `position`, `page`, `keyword`, `sortBy`, `source`, `scrapedAt`.
- **Often filled:** `promotion` (85% of products), `tags`, `priceDisplay`, `originalPrice`, `discountPercent` and `skuId` (about 40%; the discount fields appear only when the card shows a struck-through price).
- **Sometimes filled:** `deliveryEstimate` (about 30%), `rating` and `sold` for products with few or no orders (when you sort by price, 20-25% of cheap listings have none yet, and they come back null).
- **Never filled: store name and store ID.** AliExpress does not put the store on the search card. See Limits.

#### How prices are read

AliExpress shows a price for a US visitor, in USD, and that price is often a promotional price (new-user and "Dollar Express" deals), so it can be far below the seller's regular price. `price` is the sale price on the card. `priceSource` is `"card"` when the card prints the price (`priceDisplay` and `originalPrice` then come with it) and `"tracking"` when the card prints none and the same sale price is read from the card's tracking data (in cents, converted to USD). If neither exists, `price` is null.

### Pricing

Pay per result: **$2 per 1,000 products** ($0.002 per product). This price applies from 21 October 2026. You pay only for products pushed to the dataset. A keyword with no matching products returns nothing and costs nothing. The run stops at your maximum charge.

Worked example: 10 keywords at 100 products each is 1,000 products, which costs $2. Re-running the same set every day for 30 days costs $60. A 10-product test run costs $0.02.

### Use it from the API

Run it synchronously and get the products back as JSON. Replace `<YOUR_APIFY_TOKEN>` with your token.

```bash
curl -X POST "https://api.apify.com/v2/acts/datagleaner~aliexpress-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["phone case"], "sortBy": "orders", "maxItems": 20}'
```

It also works from n8n, Make or Zapier through the Apify integrations, since the output is a flat JSON record per product.

### Use with Python

`pip install apify-client`, set the `APIFY_TOKEN` environment variable, and run. This input returns at most 10 products, about $0.02.

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("datagleaner/aliexpress-scraper").call(run_input={
    "keywords": ["phone case"],
    "sortBy": "orders",
    "maxItems": 10,
})
for p in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(p["title"][:60], p["price"], p["sold"], p["rating"])
```

### Use with JavaScript / Node.js

`npm install apify-client`, set `APIFY_TOKEN`, and run it as an ES module (`.mjs`).

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('datagleaner/aliexpress-scraper').call({
    keywords: ['phone case'],
    sortBy: 'orders',
    maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const p of items) console.log(p.title.slice(0, 60), p.price, p.sold, p.rating);
```

### Use it from n8n, Make, Zapier or an AI agent

Actor ID: `datagleaner/aliexpress-scraper`

Minimal input:

```
{"keywords": ["phone case"], "sortBy": "orders", "maxItems": 10}
```

Each tool below runs this Actor with your own Apify API token.

- **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`). On n8n Cloud you install it from the community node registry. Choose **Run an Actor and get dataset**, set Actor to `datagleaner/aliexpress-scraper` and paste the input above.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to read the results. **Watch Actor Runs** can trigger a scenario when a run finishes.
- **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**. The trigger **Finished Actor run** starts a Zap when a run ends.
- **AI agents (MCP):** connect to `https://mcp.apify.com?tools=datagleaner/aliexpress-scraper`. In Claude Code:

  ```
  claude mcp add --transport http apify "https://mcp.apify.com?tools=datagleaner/aliexpress-scraper"
  ```

  Then run `/mcp` to sign in to Apify in your browser. Then ask in plain language, for example: "Find the 10 best-selling LED strip lights on AliExpress and list the cheapest three with their ratings." An agent without the Actor preloaded can find it with Apify's `search-actors` tool by searching "aliexpress".
- **LangChain (Python):**

```python
## pip install langchain-apify, then set APIFY_TOKEN in your environment
import json
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("datagleaner/aliexpress-scraper")
result = tool.invoke({"run_input": json.loads('{"keywords": ["phone case"], "sortBy": "orders", "maxItems": 10}')})
```

### Limits

- **Search results only, no product pages.** AliExpress product pages are rendered in the browser. In a test from Apify's datacenter IPs, 99 of 100 product pages loaded, but the HTML held only the title and image gallery: no price, orders, rating or store. Those fields come from signed requests this Actor does not make. So there is no product-by-URL or product-by-ID mode, and no store name or store ID, no variants or SKU list, no description and no review text.
- **Prices are what a US visitor sees**, in USD, and are frequently promotional (see "How prices are read"). The `sold` value is AliExpress's rounded label ("10,000+ sold"); `tradeCount` is the exact counter behind it when AliExpress includes it.
- **A keyword with no real match** (nonsense text) returns nothing: AliExpress then fills the page with unrelated recommendations, and the Actor detects that and skips them.
- AliExpress shows its captcha page to heavy traffic. If it appears, the Actor stops that search with a clear status message and keeps what it already collected. It never solves captchas or tries to get around them. Lower the volume, raise `requestDelaySecs`, or retry later.
- AliExpress ranking and prices change by the minute, and results can differ slightly between runs.

### FAQ

**Is there an AliExpress API?** The official AliExpress APIs are for approved affiliates and sellers. This Actor works as a simple one for search data: you call the Apify API with a keyword and it returns JSON.

**Can I look up a product by URL or ID?** Not in this version (see Limits). Search for the product's title, or its keyword, to get its card.

**How do I find best sellers?** Use `sortBy: "orders"` (the default). `sold` and `tradeCount` show the volume.

**How do I track prices over time?** Schedule the Actor daily for the same keywords and compare `price` and `discountPercent` between runs by `id`. Each record carries `scrapedAt`.

**Why is a price so low?** AliExpress shows promotional prices such as new-user deals. `originalPrice` and `discountPercent` show the list price when the card carries it.

**Do I need a proxy?** The default is the Apify datacenter proxy, which returned full results in testing. A run without a proxy on Apify also worked in a short test.

### Responsible use

This Actor reads publicly visible AliExpress search pages without logging in. Use the data in line with AliExpress's terms. The records are product data and contain no personal information. If you combine them with anything else about individuals, the data-protection obligations are yours.

# Actor input Schema

## `keywords` (type: `array`):

What to search for on AliExpress, as you would type it in the search box: `phone case`, `led strip light`, `wireless earbuds`. Each keyword returns up to `maxItems` products.

## `searchUrls` (type: `array`):

AliExpress search URLs, e.g. `https://www.aliexpress.com/wholesale?SearchText=phone+case&SortType=price_asc`. The keyword, sort order and price range in the URL are used. Product page URLs are not supported.

## `sortBy` (type: `string`):

Result order. `Most orders` returns the best sellers first.

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

Stops after this many products for each keyword or search URL. AliExpress returns 60 products per result page.

## `minPrice` (type: `number`):

Only products priced at or above this amount.

## `maxPrice` (type: `number`):

Only products priced at or below this amount.

## `requestDelaySecs` (type: `number`):

Polite pacing between result pages. Lower is faster and raises the chance of being blocked.

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

Apify datacenter proxy by default. It returns US pricing in USD with full sold counts and ratings.

## Actor input object example

```json
{
  "keywords": [
    "phone case"
  ],
  "sortBy": "orders",
  "maxItems": 60,
  "requestDelaySecs": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `products` (type: `string`):

No description

## `results` (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 = {
    "keywords": [
        "phone case"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/aliexpress-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 = {
    "keywords": ["phone case"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("datagleaner/aliexpress-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 '{
  "keywords": [
    "phone case"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call datagleaner/aliexpress-scraper --silent --output-dataset

```

## MCP server setup

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