# AliExpress Search Scraper — past page 60, exact units sold (`pampadata/aliexpress-search-scraper`) Actor

Every product of an AliExpress search, past its 60-page stop, each product once, with exact units sold.

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

## Pricing

from $1.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

Every product of an **AliExpress search**, **past AliExpress's 60-page stop**, each product **once**, with the **exact units sold** (not "10,000+"), prices in your currency for the country you ship to, and a plain per-search check of how the list ended.

*Versión en español más abajo.*

### Quick facts

- **What it does:** Every product of an AliExpress search, past AliExpress's 60-page stop (split by price bands), each product once, with exact units sold, prices in your currency for the country you ship to.
- **Use it for:** product research, price and sales tracking of a search, supplier lists, catalogue snapshots.
- **Not for:** product pages (store name, variants, shipping cost, reviews), store pages or category links (not in this version); image search.
- **Input:** `searches` (required): words as typed on AliExpress or AliExpress search links. Optional: `shipTo` (default US), `currency` (default USD), `sort`, `minPrice`/`maxPrice`, `freeShippingOnly`, `minRating`, `maxProductsPerSearch` (0 = all), `goPastPageLimit` (default on), `includeRecommended` (default off).
- **Output:** one dataset row per product, and one `SUMMARY` record with how each search's list ended. Every field with its type is under *Output reference* below.
- **Charged events (pay per event):** `product` USD 0.0015 per product delivered (USD 1.50 per 1,000); plus Apify's standard start event `apify-actor-start`.
- **Never charged:** repeats, "recommended for you" cards, products below your minimum rating, searches that fail, the SUMMARY record.
- **Limits:** stops at `maxProductsPerSearch` or at your maximum charge per run (SUMMARY `stoppedBy`); `aliexpressEstimate` is AliExpress's own number, not a count; residential IPs are used and included in the price.
- **Run it from:** Apify Console, the Apify API or an AI agent through the Apify MCP server (Actor `pampadata/aliexpress-search-scraper`), with schedules and integrations.

#### Minimal input

A small input that works, taken from this Actor's own tests; every other field is optional:

```json
{
  "searches": [
    "led strip"
  ],
  "sort": "orders",
  "maxProductsPerSearch": 60
}
```

### Why this one

- **Past the 60-page stop.** AliExpress never shows more than 60 pages of a search (about 3,600 cards), and those pages repeat products. When a search reaches page 60, this Actor splits it into price bands and reads each one until it runs out, splitting again any band that also reaches page 60. Test on 2026-10-09:

| Search "fishing reel", ship to US | Cards read | Distinct products |
|---|---|---|
| AliExpress's 60 pages (the same run, before splitting) | about 3,600 | 2,311 |
| This Actor (pages 1-60 + price bands) | 15,040 | **9,436** |

- **Each product once, and you pay once.** Repeats inside a search, across price bands and across the searches of a run are skipped and not charged. The SUMMARY counts them.
- **Exact units sold.** AliExpress rounds the text ("4K+ sold", "100K+ sold") but keeps the real number in the page: you get both (`soldCount` 4,809 and `soldText` "4K+ sold"). Another AliExpress Actor, run on the same search the same day, returned 4 for "4K+ sold" in 19 of 52 products.
- **No hidden "recommended" filler.** Some AliExpress answers mix up to 30 "recommended for you" cards into a results page (no units sold, outside your sort order). The Actor asks that page again on another IP, keeps the real results, and never charges a recommendation card.
- **Honest prices.** Cards that AliExpress shows as a new-user "free gift" don't carry the regular price in the search page; those rows say `newUserGiftOffer: true` and leave the price empty instead of printing a promo amount as the price.
- **The check per search** (SUMMARY record): pages read, price bands, repeats skipped, recommendation cards skipped, products below your minimum rating, whether the search reached page 60, how many products came before splitting, and `listRanOut: true` only when every list ended before page 60 with no errors. AliExpress's own "results" number is kept as `aliexpressEstimate`, but it is not a count (it moved between 9,251 and 12,329 for the same search in one minute).

### Input

| Field | What it does |
|---|---|
| `searches` | Words as you would type them on AliExpress (`fishing reel`), or an AliExpress search link (`https://www.aliexpress.com/w/wholesale-led-strip.html?minPrice=3&sortType=price_desc`). Price and sort in a link are kept. |
| `shipTo` | Country the prices and delivery times are for (US, GB, DE, FR, ES, BR, MX, AU, CA and more). |
| `currency` | USD, EUR, GBP, BRL, MXN, AUD, CAD... AliExpress converts the prices. |
| `sort` | Best match, most orders, price low to high, price high to low. |
| `minPrice`, `maxPrice` | In your currency. |
| `freeShippingOnly` | AliExpress's own "Free shipping" filter. |
| `minRating` | Only products rated at least this (e.g. 4.5). Products below it are read but not delivered or charged. |
| `maxProductsPerSearch` | 0 = everything AliExpress will show. Set a limit for quick tests. |
| `goPastPageLimit` | On by default. Off = stop at page 60. |
| `includeRecommended` | Off by default. On = also deliver AliExpress's "recommended" cards, marked `isRecommendation: true`. |

### What you get for each product

`productId` (the global id; the US site shows the same product as 3256…, the Actor converts it), `url`, `title`, `price`, `originalPrice`, `discountPercent`, `currency`, `priceText`, `newUserGiftOffer`, `rating`, `soldCount`, `soldText`, `launchDate`, `isChoice`, `isSponsored`, `isRecommendation`, `freeShipping`, `shipFrom`, `deliveryDaysMin`, `deliveryDaysMax`, `deliveryDateFrom`, `deliveryDateTo`, `badges`, `categoryIds`, `imageUrl`, `images`, `skuId`, `search`, `shipTo`, `page`, `position`, `scrapedAt`. Fields AliExpress does not show on a card stay empty; nothing is guessed.

#### Example (trimmed)

```json
{
  "productId": "1005012720812769",
  "url": "https://www.aliexpress.com/item/1005012720812769.html",
  "title": "Rooblinos BR 6.3:1 7+1BB Baitcaster Fishing Reel Bait Caster Baitcasting Reel Fishing Tackle",
  "price": 16.2,
  "originalPrice": 50,
  "discountPercent": 67,
  "currency": "USD",
  "soldCount": 95,
  "soldText": "95 sold",
  "launchDate": "2026-07-12",
  "isChoice": false,
  "isSponsored": false,
  "shipFrom": "US",
  "deliveryDaysMin": 6,
  "deliveryDaysMax": 12,
  "deliveryDateFrom": "2026-10-14",
  "deliveryDateTo": "2026-10-20",
  "categoryIds": ["18", "100005537", "100005542"],
  "search": "fishing reel",
  "shipTo": "US",
  "page": 1,
  "position": 1
}
```

### Price

You pay only for products delivered: **USD 1.50 per 1,000 products** (USD 0.0015 each). No charge per run beyond Apify's standard start event, nothing for repeats, recommendation cards, products below your minimum rating, or searches that fail. Set a maximum charge per run in Apify and the Actor stops there.

### How long it takes

About 100 products in 10 seconds; a whole broad search past page 60 ("fishing reel": 9,436 products, 340 pages, 8 price bands) in about 10 minutes.

### Good to know

- Search links only (`/w/wholesale-....html` or `?SearchText=`). Product pages, store pages and category links are not read in this version.
- Store name, variants, shipping cost and reviews are on the product page, not on search cards; they are not in this version.
- Residential IPs are included in the price: AliExpress shows its captcha to datacenter IPs within a few pages.
- Not affiliated with AliExpress or Alibaba. It reads the same public search pages any visitor sees, without logging in.

### Output reference

#### Dataset: one row per product

| Field | Type | What it is |
|---|---|---|
| `productId` | string | Global product ID (the US site's 3256… IDs are converted). |
| `url` | string | Product link. |
| `title` | string | Product title. |
| `price` | number or null | Price in `currency`; null on new-user "free gift" cards (newUserGiftOffer true). |
| `originalPrice` | number or null | Price before discount, when shown. |
| `discountPercent` | integer or null | Discount in %, when shown. |
| `currency` | string or null | ISO currency code of the prices. |
| `priceText` | string or null | Price as written. |
| `newUserGiftOffer` | boolean | true on new-user "free gift" cards (no regular price on the search page). |
| `rating` | number or null | Star rating, when shown. |
| `soldCount` | integer or null | Exact units sold as kept in the page (e.g. 4809 where the text says 4K+). |
| `soldText` | string or null | Units sold as written, e.g. "4K+ sold". |
| `launchDate` | string | Product launch date (YYYY-MM-DD). |
| `isChoice` | boolean | AliExpress Choice item. |
| `isSponsored` | boolean | Sponsored card. |
| `isRecommendation` | boolean | Only with includeRecommended: true on "recommended for you" cards. |
| `freeShipping` | boolean | Free shipping shown. |
| `shipFrom` | string or null | Country it ships from. |
| `deliveryDaysMin` | integer | Delivery estimate, minimum days (only when the card shows one). |
| `deliveryDaysMax` | integer | Delivery estimate, maximum days (only when shown). |
| `deliveryDateFrom` | string | Delivery estimate, first date (only when shown). |
| `deliveryDateTo` | string | Delivery estimate, last date (only when shown). |
| `badges` | array of string | Badges on the card. |
| `categoryIds` | array of string | AliExpress category IDs. |
| `imageUrl` | string | Main image link. |
| `images` | array of string | Image links. |
| `skuId` | string or null | SKU ID of the card. |
| `search` | string | The search this product came from. |
| `shipTo` | string | Country the prices are for. |
| `page` | integer | Result page it was found on. |
| `position` | integer | Position on that page. |
| `scrapedAt` | string | When it was read (ISO 8601, UTC). |

#### SUMMARY record (run's key-value store, never charged)

| Field | Type | What it is |
|---|---|---|
| `searches` | array of object | One item per search (fields below). |
| `productsDelivered` | integer | Products delivered in the run. |
| `requests` | object | Request counters of the run (requests, retries, refusals or blocks, failures; whether the run moved to residential IPs). |
| `shipTo`, `currency` | string | Settings of the run. |

Each item of `searches`:
| Field | Type | What it is |
|---|---|---|
| `input`, `keyword`, `filters` | string, string, object | Your search and the filters used. |
| `delivered` | integer | Products delivered (and charged). |
| `rowsSeen`, `pagesRead`, `pagesFetched` | integer | Cards and pages read. |
| `repeatsSkipped` | integer | Repeats skipped (not charged). |
| `recommendedSkipped` | integer | "Recommended for you" cards skipped (not charged). |
| `belowMinRating` | integer | Products below minRating (not charged). |
| `alreadyDelivered` | integer | Products already delivered by another search of the run. |
| `degradedPagesKept` | integer | Pages that still held recommendation cards after the retries. |
| `bands`, `splits` | integer | Price bands read past page 60. |
| `reachedPageLimit` | boolean | The search reached page 60. |
| `deliveredBeforeSplitting` | integer or null | Products delivered before splitting. |
| `aliexpressEstimate` | integer or null | AliExpress's own "results" number (not a count). |
| `listRanOut` | boolean | true only when every list ended before page 60 with no errors. |
| `incompleteParts` | array of object | Parts not read in full: priceBand, why. |
| `stoppedBy` | string or null | Why it stopped early (maxProductsPerSearch, your maximum charge). |
| `errors` | array of string | Errors met. |

### More Actors by this developer

- [Google Ads Transparency Scraper](https://apify.com/pampadata/google-ads-transparency-scraper)
- [SEEK Jobs Scraper (Seek, JobStreet, Jobsdb)](https://apify.com/pampadata/seek-jobs-scraper)
- [Career Site Jobs Scraper (Workday, Greenhouse, Lever and 6 more)](https://apify.com/pampadata/career-site-jobs-scraper)
- [Google News Scraper](https://apify.com/pampadata/google-news-scraper)
- [Sports Odds vs Prediction Markets (Kalshi, Polymarket)](https://apify.com/pampadata/sports-odds-vs-prediction-markets)
- [Google Trends Scraper](https://apify.com/pampadata/google-trends-scraper)
- [YouTube Transcripts in Bulk (whole channels, playlists)](https://apify.com/pampadata/youtube-transcripts-bulk)

***

### Versión en español

Todos los productos de una **búsqueda de AliExpress**, **más allá del tope de 60 páginas**, cada producto **una sola vez**, con los **vendidos exactos** (no "10.000+"), precios en tu moneda para el país de envío, y un control por búsqueda de cómo terminó la lista.

#### De un vistazo

- **Qué hace:** Todos los productos de una búsqueda de AliExpress, más allá del tope de 60 páginas (por bandas de precio), cada uno una vez, con vendidos exactos y precios en tu moneda para el país de envío.
- **Sirve para:** investigación de productos, seguimiento de precios y ventas de una búsqueda, listas de proveedores.
- **No sirve para:** páginas de producto (tienda, variantes, envío, reseñas), de tienda o de categoría (no están en esta versión); búsqueda por imagen.
- **Entrada:** `searches` (obligatorio): palabras o enlaces de búsqueda. Opcionales: `shipTo` (US), `currency` (USD), `sort`, precios, `freeShippingOnly`, `minRating`, `maxProductsPerSearch`, `goPastPageLimit`, `includeRecommended`. Ejemplo mínimo en JSON: sección *Minimal input* de la parte en inglés.
- **Salida:** una fila por producto y un registro `SUMMARY` con cómo terminó cada búsqueda.
- **Eventos que se cobran:** `product` USD 0,0015 por producto entregado (USD 1,50 cada 1.000); más `apify-actor-start`.
- **Nunca se cobra:** repetidos, tarjetas "recomendadas", productos bajo tu nota mínima, búsquedas fallidas, el SUMMARY.
- **Límites:** se detiene en `maxProductsPerSearch` o en tu costo máximo por corrida (`stoppedBy`).

#### Por qué este

- **Pasa el tope de 60 páginas.** AliExpress nunca muestra más de 60 páginas de una búsqueda (unas 3.600 tarjetas), y esas páginas repiten productos. Cuando una búsqueda llega a la página 60, el Actor la parte en bandas de precio y lee cada una hasta que se termina. Prueba del 2026-10-09, "fishing reel", envío a EE. UU.: las 60 páginas de AliExpress dan 2.311 productos distintos; este Actor, **9.436** (4 veces más).
- **Cada producto una vez, y se cobra una vez.** Los repetidos dentro de una búsqueda, entre bandas y entre búsquedas de la misma corrida no se entregan ni se cobran.
- **Vendidos exactos.** AliExpress redondea el texto ("4K+ sold") pero guarda el número real en la página: recibís los dos. Otro Actor de AliExpress, en la misma búsqueda y el mismo día, devolvió 4 para "4K+ sold" en 19 de 52 productos.
- **Sin "recomendados" de relleno.** A veces AliExpress mete hasta 30 tarjetas de "recomendados para vos" en una página de resultados. El Actor pide esa página otra vez desde otra IP y nunca cobra una tarjeta recomendada.
- **Precios honestos.** Las tarjetas de "regalo para comprador nuevo" no traen el precio normal en la búsqueda: esas filas dicen `newUserGiftOffer: true` y dejan el precio vacío.
- **Control por búsqueda** (registro SUMMARY): páginas leídas, bandas de precio, repetidos, recomendados salteados, si llegó a la página 60 y `listRanOut: true` solo cuando todas las listas terminaron antes de la página 60 sin errores.

#### Precio

**Precio:** USD 1,50 cada 1.000 productos entregados (USD 0,0015 cada uno). Sin cobro por corrida aparte del evento estándar de inicio de Apify; nada por repetidos, recomendados, productos debajo de tu nota mínima ni búsquedas que fallan.

#### Para saber

- Solo links de búsqueda. Páginas de producto, de tienda y de categoría no se leen en esta versión.
- Nombre de la tienda, variantes, costo de envío y reseñas están en la página del producto: no están en esta versión.
- Las IP residenciales están incluidas en el precio.
- No está afiliado a AliExpress ni a Alibaba. Lee las mismas páginas públicas de búsqueda que ve cualquier visitante, sin iniciar sesión.

# Actor input Schema

## `searches` (type: `array`):

One per line: words as you would type them on AliExpress ("fishing reel", "phone case"), or an AliExpress search link (aliexpress.com/w/wholesale-....html). Price and sort in a link are kept.

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

Prices, delivery times and what AliExpress lists depend on the country it ships to.

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

Prices come in this currency (AliExpress converts them). minPrice and maxPrice are in it too.

## `sort` (type: `string`):

Order of the list. With a limit per search, it decides which products you get first.

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

In the currency above. Empty = no minimum.

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

In the currency above. Empty = no maximum.

## `freeShippingOnly` (type: `boolean`):

AliExpress's own "Free shipping" filter.

## `minRating` (type: `number`):

Deliver only products rated at least this (for example 4.5). Products below it, or without a rating yet, are skipped and not charged; the SUMMARY counts them. Empty = all.

## `maxProductsPerSearch` (type: `integer`):

0 = every product AliExpress will show for the search. You pay per product, so set a limit for quick tests.

## `goPastPageLimit` (type: `boolean`):

AliExpress never shows more than 60 pages of a search. When a search reaches page 60, the run splits it into price bands and reads each one, so you get the products AliExpress would not show. Turn off to stop at page 60.

## `includeRecommended` (type: `boolean`):

Some result pages mix in up to 30 'recommended for you' cards that are not search results (no units sold, rating or launch date, and outside your sort order). They are left out and not charged; the SUMMARY counts them. Tick to receive them too, marked isRecommendation: true.

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

Leave as is: residential IPs are included in the price (AliExpress shows its captcha to datacenter IPs within a few pages). If you pick your own proxies, they are used as given.

## Actor input object example

```json
{
  "searches": [
    "fishing reel"
  ],
  "shipTo": "US",
  "currency": "USD",
  "sort": "relevance",
  "freeShippingOnly": false,
  "maxProductsPerSearch": 100,
  "goPastPageLimit": true,
  "includeRecommended": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset items: one row per product delivered (productId, url, title, price, originalPrice, discountPercent, currency, rating, soldCount (exact), soldText, launchDate, shipping and delivery fields, images, search, page, position). Charged per row: event `product`.

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

Key-value record SUMMARY: per search, pages read, price bands, repeats and recommendation cards skipped, reachedPageLimit, listRanOut, incompleteParts, stoppedBy; run totals. Not charged.

# 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 = {
    "searches": [
        "fishing reel"
    ],
    "shipTo": "US",
    "currency": "USD",
    "maxProductsPerSearch": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("pampadata/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 = {
    "searches": ["fishing reel"],
    "shipTo": "US",
    "currency": "USD",
    "maxProductsPerSearch": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("pampadata/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 '{
  "searches": [
    "fishing reel"
  ],
  "shipTo": "US",
  "currency": "USD",
  "maxProductsPerSearch": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call pampadata/aliexpress-search-scraper --silent --output-dataset

```

## MCP server setup

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