# AliExpress Search Scraper: Prices, Orders & Ratings (`atlasdataworks/aliexpress-search-scraper`) Actor

Scrape AliExpress search and category results into one flat table: price, list price, discount, seller price, currency, rating, exact orders count, Choice, ship-from, delivery dates, images. Ship-to country, currency and language pinned per run. No browser, no login.

- **URL**: https://apify.com/atlasdataworks/aliexpress-search-scraper.md
- **Developed by:** [Atlas Dataworks](https://apify.com/atlasdataworks) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 product scrapeds

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 Search Scraper: prices, orders and ratings for any keyword or category

Scrape **AliExpress product data** from keyword search and category pages into one flat table:
price, list price, discount, currency, rating, **exact orders count**, AliExpress Choice, ship-from
country and delivery dates. You pick the **ship-to country, currency and language**, so every row is
priced for the market you sell in. No login, no browser, no proxy setup. **$3.00 per 1,000
products**, and you pay only for products delivered.

### What does this AliExpress scraper do?

- **Searches AliExpress by keyword** and returns every product card on the pages it reads, up to
  3,600 per keyword (60 per page, AliExpress stops at page 60).
- **Reads category and filtered search URLs** you paste from your browser. The URL's own query
  parameters (filters, sort order) are kept as they are; only the page number changes.
- **Pins the market per run.** Ship-to country, currency and title language are set on every
  request, so a run for Germany comes back in EUR with German delivery dates and does not drift into
  whatever country the network exit happened to be in.
- **Removes duplicates.** AliExpress repeats items across result pages; the max you set counts
  unique products, and you are charged once per product.
- **Leaves ads out** by default. Include them with one switch and they come flagged
  `sponsored: true`.

### Who uses it

- **Dropshippers and e-commerce sellers.** Find what sells (orders count, rating), at what price,
  shipped from where and how fast, before you list it.
- **Price monitoring.** Schedule a daily run on your keywords or a category and track price, list
  price and discount over time.
- **Product and market research.** Pull a whole category with orders and ratings to size a niche.
- **Sourcing.** Compare the same product across sellers by price, ship-from warehouse and delivery
  window.
- **AI agents.** Call it as an MCP tool and get typed JSON back (see below).

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

Pay per event: **$0.003 per product delivered** (`product-scraped`), plus Apify's platform rows
(about $0.00005 per run start and per result). You do not pay for run time, proxies or compute.

| What you scrape | Products | Cost |
|---|---|---|
| One keyword, one results page (the prefilled run) | 60 | $0.18 |
| One keyword, 500 products | 500 | $1.50 |
| **1,000 products** from any mix of keywords and categories | 1,000 | **$3.00** |
| A full category, 60 pages | 3,600 | $10.80 |

To cap a run, set **Max cost per run** in the run options: the run delivers what fits and stops,
and never charges past it.

### How to scrape AliExpress products

1. Click **Try for free** (or **Start**). The input is prefilled with the keyword `phone case` and
   60 products, so one click returns data.
2. Replace it with your own keywords or category URLs, and pick the ship-to country, currency and
   language.
3. Run it, then download the results as **JSON, CSV, Excel, XML or HTML**, or read them through the
   Apify API, a schedule, or an integration (Make, Zapier, n8n, Google Sheets, webhooks).

### Input

| Field | What it does |
|---|---|
| `searchQueries` | Keywords to search, e.g. `phone case`. |
| `categoryUrls` | Category or search URLs copied from your browser, e.g. `https://www.aliexpress.com/category/100003109/women-clothing.html`. Item pages are not accepted here. |
| `maxItemsPerQuery` | Most unique products per keyword or URL, 1 to 3,600. |
| `shipTo` | Ship-to country: US, GB, DE, FR, ES, IT, NL, PL, CA, AU. Prices and delivery dates are computed for it. |
| `currency` | USD, EUR, GBP, PLN, CAD or AUD. |
| `language` | Language of product titles: English, German, French, Spanish, Italian, Dutch or Polish. |
| `includeSponsored` | Include ad cards, always flagged `sponsored: true`. Default off. |

Example input:

```json
{
  "searchQueries": ["wireless earbuds", "phone case"],
  "maxItemsPerQuery": 300,
  "shipTo": "DE",
  "currency": "EUR",
  "language": "en_US"
}
```

### Output

One record per unique product (a real row from a US run):

```json
{
  "itemId": "1005012374506428",
  "url": "https://www.aliexpress.com/item/1005012374506428.html",
  "title": "HTC NE76 Bluetooth Earphones, AI Translator Earbuds Mini Invisible Sleep Earbuds Soft Wireless Headphones Orange",
  "imageUrl": "https://ae-pic-a1.aliexpress-media.com/kf/S4c5d4a9c4d964b3c9d2bb91b8db9f878H.jpg",
  "images": ["https://ae-pic-a1.aliexpress-media.com/kf/S4c5d4a9c4d964b3c9d2bb91b8db9f878H.jpg", "..."],
  "price": 11.79,
  "originalPrice": 26,
  "discountPct": 54,
  "sellerOfferPrice": 25.56,
  "currency": "USD",
  "rating": 4.9,
  "soldCount": 1806,
  "soldText": "1,000+ sold",
  "sponsored": false,
  "choice": true,
  "shipFrom": "CN",
  "deliveryMinDays": 6,
  "deliveryMaxDays": 11,
  "deliveryFrom": "2026-10-19",
  "deliveryTo": "2026-10-24",
  "sellingPoints": ["Save $14.21", "Delivery: Oct 19 - 24"],
  "categoryIds": ["44", "100000306", "63705"],
  "firstListedAt": "2026-05-25",
  "position": 3,
  "page": 2,
  "shipTo": "US",
  "source": "search:wireless earbuds",
  "scrapedAt": "2026-10-13T07:11:43.023Z"
}
```

- `price` is what the card shows a signed-out shopper; it can include AliExpress's own new-user
  discounts. `originalPrice` is the struck-through price, filled only when it is above `price`.
- `soldCount` is the exact orders count where the page carries it (`1806` above, while the card
  says "1,000+ sold"), otherwise the floor of the label.
- `sellerOfferPrice` is the seller's offer amount from the page data. How it relates to `price`
  differs by market, so it is reported as found.
- `position` and `page` are the rank as AliExpress ordered the results.
- Unknown values are `null`, never `0`: a product with no rating is not a product rated 0.

Each run also writes a **summary** to the key-value store under `OUTPUT`: `priceCompleteness`
(share of products that came back with a price), `currenciesSeen` (so a currency mismatch is visible,
not silent), `degradedSources` (any keyword or URL that failed, so an empty result is told apart from
a failed one), and counts per source.

### Why this AliExpress scraper

- **Every row priced for your market.** Most AliExpress scrapers return whatever currency the proxy
  happened to land in. This one pins ship-to, currency and language on every request and reports
  the currencies it actually got.
- **Exact orders counts**, not just "1,000+ sold", wherever the page carries them.
- **Unique products, charged once.** Duplicates across pages are removed before delivery and before
  charging.
- **Measured.** Price completeness is reported on every run. In our test runs (US keyword, 150
  products; German category URL, 55 products) 100% of products came back priced.
- **Light.** One request returns 60 products, so 1,000 products take about 17 requests. A
  150-product run takes about 20 seconds.

### Use it from an AI agent (MCP) or the API

The actor is callable as an MCP tool through Apify's MCP server. Example prompts:

> "Find the 100 best-selling wireless earbuds on AliExpress shipped to Germany, with price in EUR
> and orders count."

> "List AliExpress Choice phone cases under $5 with delivery to the US, sorted by orders."

From code, one HTTP call runs it and returns the products:

```bash
curl -X POST "https://api.apify.com/v2/acts/atlasdataworks~aliexpress-search-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries": ["phone case"], "maxItemsPerQuery": 60, "shipTo": "US", "currency": "USD"}'
```

### FAQ

**Is it legal to scrape AliExpress?** This actor reads only public search and category pages that
anyone can open without signing in, and collects product data, not personal data. Whether your use
is allowed depends on your jurisdiction and purpose; check with a lawyer if you are unsure.

**Does it return product detail pages, SKUs or reviews?** Not yet. This actor reads search and
category results, which carry price, orders, rating, shipping and delivery for every card. Per-SKU
prices and stock come from the item page, which is the next feature. Review text is not collected:
it carries reviewer names, and this actor collects no personal data.

**Why is a price lower than on the product page?** The search card can show AliExpress's new-user or
welcome-deal price. The struck-through `originalPrice` and `sellerOfferPrice` sit next to it so you
can tell.

**Do I need a proxy, cookies or an AliExpress account?** No. Access is included in the price.

**Can I monitor prices on a schedule?** Yes. Save your input as a task and add an Apify schedule;
each run is a new dataset you can compare with the last.

**Something broke or a field is missing.** Open an issue on the actor's Issues tab. AliExpress
changes its pages; reports get fixed.

### Also from Atlas DataWorks

- [Amazon Product Scraper](https://apify.com/atlasdataworks/amazon-unified-extractor): search, Best
  Sellers and ASIN detail in one run, the same $3.00 per 1,000.

### Limits

- **Search and category pages only**: no item-page detail, SKUs or reviews yet (see the FAQ).
- AliExpress shows at most 60 pages per search; for more, split by category or narrower keywords.
- Delivery dates and prices are AliExpress's estimate for the chosen ship-to country at run time.

# Actor input Schema

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

Keywords to search on AliExpress, e.g. "phone case". Each keyword returns up to the max products below, 60 per results page.

## `categoryUrls` (type: `array`):

AliExpress category or search URLs copied from your browser, e.g. https://www.aliexpress.com/category/100003109/women-clothing.html. Filters in the URL are kept. Item pages are not accepted here.

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

Upper bound on products returned per keyword or URL. AliExpress shows 60 per page.

## `shipTo` (type: `string`):

Country AliExpress prices and delivery estimates are computed for.

## `currency` (type: `string`):

Currency prices are returned in. The run summary reports the currency AliExpress actually answered in.

## `language` (type: `string`):

Language AliExpress uses for product titles.

## `includeSponsored` (type: `boolean`):

Ads are excluded by default and always flagged sponsored=true when included.

## Actor input object example

```json
{
  "searchQueries": [
    "phone case"
  ],
  "maxItemsPerQuery": 60,
  "shipTo": "US",
  "currency": "USD",
  "language": "en_US",
  "includeSponsored": false
}
```

# Actor output Schema

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

One record per unique AliExpress item across every keyword and URL, billed once. Prices are numbers in the run's currency; unknown values are null, never zero.

## `runSummary` (type: `string`):

Per-run counts and health: priceCompleteness, the currencies AliExpress answered in, per-source counts, degradedSources and chargeLimitReached.

# 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": [
        "phone case"
    ],
    "maxItemsPerQuery": 60
};

// Run the Actor and wait for it to finish
const run = await client.actor("atlasdataworks/aliexpress-search-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": ["phone case"],
    "maxItemsPerQuery": 60,
}

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

```

## MCP server setup

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