# AliExpress Search Scraper — Prices, Orders, Ratings (`architekture/aliexpress-search-scraper`) Actor

Search AliExpress by keyword: prices, discounts, order counts, ratings, sponsored flags and delivery estimates. Sort by orders or price and filter by price range. Pay $2.50 per 1,000 delivered products, with usage included. Search cards only; no product-detail data.

- **URL**: https://apify.com/architekture/aliexpress-search-scraper.md
- **Developed by:** [architek.earth](https://apify.com/architekture) (community)
- **Categories:** AI, E-commerce
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.50 / 1,000 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 Search Scraper — Prices, Orders, Ratings

**Recorded run, 17 Oct 2026: the 120 best-selling mechanical keyboards between $20 and $60 in 14 seconds. Every price inside the range, sorted by real order count (31,742 → 170), 0 blocked requests, exactly 120 products charged.**

From **Architekture**, makers of the Woolworths AU, Coles AU, ALDI AU, Tesco UK and Sainsbury's UK scrapers.

Type the keywords a shopper would type, get every product card AliExpress shows for them as clean JSON: sale price, original price, discount, the exact order count, rating, image, item link, whether the listing is sponsored, free-shipping and delivery estimate. Sort by most orders or by price, filter by price range. You pay per product delivered; failed requests are free.

| 🛍️ Marketplace | 📍 Market | 💰 From | 🔑 Standout fields |
|---|---|---|---|
| AliExpress | Global (prices in request-country currency) | $2.50 / 1,000 products | Exact order counts, sponsored flag, delivery estimates |

🤖 **Built for AI workflows.** Every row is deterministic, schema-stable JSON — feed it straight to LLM apps, RAG pipelines, or agent tool calls via the Apify API, the Apify MCP server (`mcp.apify.com`), or AI coding agents like Claude Code and Cursor.

### 🚀 Why choose this actor

- **Exact order counts, not just "10,000+ sold".** `ordersCount` is AliExpress's own integer (e.g. 37,932) next to the rounded label shown to shoppers (`ordersText`).
- **Sponsored listings are flagged.** Around a quarter of cards on some pages are ads; `isSponsored` lets you keep or drop them instead of mistaking them for organic results.
- 🌐 **Built for AliExpress's rate limit.** AliExpress blocks an IP after a handful of searches. The actor switches to a fresh IP every 4 requests and on any block, so long runs finish instead of timing out.
- 💸 **Filters you can trust.** Sort and price range are applied by AliExpress, and on page 1 of each keyword the actor checks AliExpress confirmed them; if not, `RUN_SUMMARY.warnings` says so.
- 💸 **No duplicates.** AliExpress repeats products across pages; each product is returned (and charged) once per run, even across keywords.
- 🔬 **Clean stops.** Hitting your spending limit or run timeout ends the run with a summary and everything collected so far, never a crash.

### ⚠️ Worth knowing up front

- 🔎 **Search results only.** This actor reads AliExpress search pages. It does **not** return product-page data: no SKU/variant matrix, no full description, no shipping cost, no store name or store rating. AliExpress serves those through an API behind a slider captcha, which this actor does not attempt.
- **Order counts are AliExpress's number, period unlabelled.** AliExpress shows "N sold" without saying over what period; `ordersCount` is that same count, unmodified.
- 🔎 **Prices exclude shipping and tax.** `salePrice` is the lowest variant price on the card. Shipping costs are not on search cards; `freeShipping` and `deliveryEstimate` appear only when AliExpress shows them.
- 💸 **Prices are in USD by default.** AliExpress prices in the currency of the country the request comes from; the default proxy is US, so `currency` is `USD` and `minPrice`/`maxPrice` are in dollars. Change the proxy country and both prices and the price filter switch to that country's currency (e.g. a Swedish IP returns SEK).
- **Depth:** 60 products per page, at most 60 pages (3,600) per keyword. AliExpress may report far more results (e.g. 17,763), but only the first 60 pages can be read.
- **Sort by newest** is not offered: AliExpress ignores that sort for these requests.

### ⚡ Try the example

```json
{
  "searchTerms": ["mechanical keyboard"],
  "maxItemsPerQuery": 120,
  "sortBy": "orders",
  "minPrice": 20,
  "maxPrice": 60
}
```

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | array of strings | required | Keywords, up to 100 per run. |
| `maxItemsPerQuery` | integer | `100` | Products per keyword. `0` = as many as AliExpress lists (max 3,600). |
| `sortBy` | `default` · `orders` · `priceAsc` · `priceDesc` | `default` | AliExpress sort order. `orders` = most sold first. |
| `minPrice` / `maxPrice` | number | — | Price range in the listing currency (USD on the default proxy), applied by AliExpress. |
| `proxyConfiguration` | object | Apify datacenter, US | Switch to RESIDENTIAL if a run reports blocked keywords. |
| `feedback` | string | — | A note to the maintainers. Read by a human; does not change output. |

### 🧱 Stable fields for automations

These fields keep their names and meaning across versions; new fields are only ever added. A field is **omitted** (not `null`) when AliExpress does not show it for that product.

| Field | Meaning |
|---|---|
| `itemId` | Product id used in `aliexpress.com/item/<itemId>.html`. Unique per run. |
| `productId` | AliExpress's search-card id for the same product (`itemId` + 2⁵¹). |
| `title` | Product title as shown in search. |
| `salePrice` | Lowest current price on the card, number. |
| `currency` | Currency of the prices, e.g. `USD`. |
| `originalPrice` | Struck-through price, only when higher than `salePrice`. |
| `discountPct` | Discount AliExpress displays, integer percent. |
| `ordersCount` | AliExpress order count, integer. |
| `ordersText` | The label shoppers see, e.g. `10,000+ sold`. |
| `rating` | Star rating, 0–5. |
| `imageUrl` | Main image. |
| `itemUrl` | Canonical product link (tracking parameters removed). |
| `isSponsored` | `true` for paid (ad) placements. |
| `freeShipping` | `true` when the card shows free shipping; omitted otherwise. |
| `deliveryEstimate` | Delivery window shown on the card, e.g. `Oct 22 - 27`. |
| `position` | Rank in the search results (1 = first card on page 1). |
| `source` | `{source: "search", searchTerm, page}`. |

### 📦 Output example

```json
{
  "itemId": "1005007352046243",
  "productId": "3256807165731491",
  "title": "Original Lenovo XT80 Sports Wireless Earphones with Mics, LED Power Display,Hifi Stereo Sound Bluetooth 5.3 TWS HeadphHeadphones",
  "salePrice": 12.79,
  "currency": "USD",
  "originalPrice": 35.93,
  "discountPct": 64,
  "ordersCount": 37932,
  "ordersText": "10,000+ sold",
  "rating": 4.7,
  "imageUrl": "https://ae-pic-a1.aliexpress-media.com/kf/Sc304388c77474000888a8dd1027131046.jpg",
  "itemUrl": "https://www.aliexpress.com/item/1005007352046243.html",
  "isSponsored": true,
  "deliveryEstimate": "Oct 22 - 27",
  "position": 4,
  "source": { "source": "search", "searchTerm": "bluetooth earphones", "page": 1 }
}
```

### 🧠 Advanced usage

- 💸 **Best sellers in a price band:** `sortBy: "orders"` with `minPrice`/`maxPrice`; read the first 60–120 rows.
- 💸 **Daily price monitoring:** schedule the same keywords each day and join runs on `itemId`; compare `salePrice` and `ordersCount`.
- **Organic results only:** filter `isSponsored == false`.
- 🌐 **Completion check:** read the `RUN_SUMMARY` record — `status` (`COMPLETE`, `PARTIAL`, `BLOCKED`, `BUDGET_LIMIT`, `TIME_LIMIT`, `INVALID_INPUT`), `products`, per-keyword `terms` (each with `status` `pending` · `done` · `blocked` · `layout_changed` · `error`, products `delivered` and `lastPage` reached), and `warnings`.

### 🔌 Integrations

Export as JSON, CSV, Excel or RSS; push to Google Sheets; trigger from Make, Zapier or n8n; webhook on run finish; schedule with the Apify Scheduler.

### 💸 How much does it cost?

1,000 products ≈ **$2.50**. The recorded 120-keyboard run above cost about **$0.30** and took 14 seconds. Failed requests are free. Platform usage is included.

### 💰 Pricing

| Event | Price | Covers |
|---|---|---|
| `product` | $2.50 / 1,000 | One product row delivered to the dataset |

Available to free-plan users using their Apify credits. This release has no waived-charge preview allowance: the 60-product prefill costs up to $0.15 in product events.

Platform usage and proxy are included. Nothing is charged for failed requests, failed pages or duplicate products. If a keyword is blocked partway, the products delivered before the block are kept and charged; nothing after it is.

### ❓ FAQ

**Can I get product variants, descriptions or shipping costs?** No. Those live on product pages that AliExpress protects with a slider captcha; this actor returns search-card data only.

**Can I get the seller/store name?** No, it is not on search cards.

**Is `ordersCount` lifetime or last 30 days?** AliExpress doesn't say. It is the same count behind the "N sold" label.

**Why did a keyword come back `blocked`?** AliExpress refused a page of that keyword on four fresh IPs in a row. Pages that failed were not charged; products delivered before the block are kept (and charged). Rerun the keyword, or switch the proxy to RESIDENTIAL.

**Do I need an AliExpress account or cookies?** No.

**How many products per keyword?** Up to 3,600 (60 pages of 60), fewer when AliExpress runs out or repeats itself.

**How fast?** About 5–6 seconds per page of 60 per keyword, with up to 4 keywords in parallel (recorded: 600 products from 2 keywords in 40 s).

### 🤖 For AI agents & LLM apps

`architekture/aliexpress-search-scraper` returns every product card from an AliExpress keyword search — price, discount, exact order count, rating, sponsored flag and item URL — as deterministic, schema-stable JSON, one object per product, same fields on every run, so agents and RAG pipelines can parse it without defensive code. Invoke it from any agentic workflow via the Apify API or the Apify MCP server (`mcp.apify.com`) as a tool call; pay-per-event billing means a run costs a known amount before it starts ($2.50 per 1,000 products, maxItemsPerQuery caps it). Each run writes a `RUN_SUMMARY` record with a machine-readable `status` and per-keyword outcome, so an agent can branch on `BLOCKED` or `BUDGET_LIMIT` instead of parsing logs. Honest limits: search cards only — no variants, descriptions, shipping costs or store names.

Works out of the box with LangChain, LlamaIndex and AI coding agents — call it as a tool from Claude Code, Cursor, or any MCP client via `mcp.apify.com`.

### 🧰 More Architekture scrapers

- 🔎 **E-commerce & grocery:** AliExpress Search (you are here) · Woolworths AU · Coles AU · ALDI AU · Woolworths NZ · Tesco UK · Sainsbury's UK
- 🎬 **Video & content:** YouTube Transcripts · Substack · Hacker News · Reddit · Telegram Channels
- **Companies & research:** Y Combinator Companies · Product Hunt · UK Companies House · SEC EDGAR · PubMed · arXiv

Field names are similar across our e-commerce actors but not identical; map them per actor.

### 🙋 Support

Open an Issue on this actor's page; a human replies within a day.

### ⚖️ Legal compliance

This actor reads publicly available search pages, without logging in. You are responsible for how you use the data, including AliExpress's Terms of Service, intellectual property in product titles and images, and data-protection law where it applies.

### 📝 Changelog

- 🔎 **2026-10-17** — 1.0: keyword search with server-verified sort (orders, price) and price range; exact order counts; sponsored flag; free-shipping and delivery estimate; de-duplication across pages and keywords; IP rotation under AliExpress's per-IP limit; clean stops at spending limit and timeout; resumable after platform migration.

# Actor input Schema

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

Product keywords, searched on aliexpress.com exactly as a shopper would type them. Up to 100 per run.

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

Stop each search term after this many products. 0 = as many as AliExpress lists (60 per page, at most 60 pages = 3,600). Products already returned for an earlier term are not repeated.

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

AliExpress sort order. 'orders' = most sold first. On page 1 of each keyword the actor checks AliExpress confirmed the sort, and warns in RUN_SUMMARY if it did not.

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

Only products whose lowest sale price is at least this amount, in the listing currency (USD on the default proxy). Applied by AliExpress; 0 means no minimum.

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

Only products whose lowest sale price is at most this amount (must be above 0). Applied by AliExpress.

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

Apify datacenter proxy in the US is the tested default: AliExpress lists prices in the currency of the request's country, so US = USD (and minPrice/maxPrice are read in that currency). The actor switches IP every 4 requests to stay under AliExpress's limit. Choose RESIDENTIAL if runs report 'blocked' terms.

## `feedback` (type: `string`):

Tell the maintainers what you needed and did not get. Read by a human; does not change the output.

## Actor input object example

```json
{
  "searchTerms": [
    "bluetooth earphones"
  ],
  "maxItemsPerQuery": 60,
  "sortBy": "default",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

One row per product in the default dataset.

## `summary` (type: `string`):

RUN_SUMMARY record: overall status and per-term counts.

# 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": [
        "bluetooth earphones"
    ],
    "maxItemsPerQuery": 60,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("architekture/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 = {
    "searchTerms": ["bluetooth earphones"],
    "maxItemsPerQuery": 60,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("architekture/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 '{
  "searchTerms": [
    "bluetooth earphones"
  ],
  "maxItemsPerQuery": 60,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}' |
apify call architekture/aliexpress-search-scraper --silent --output-dataset

```

## MCP server setup

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