# AliExpress Product Trends Scraper (`rogelio.perez/aliexpress-product-trends-scraper`) Actor

AliExpress scraper for prices, exact sold counts and daily sales. Search by keyword or URL, pick your ship-to country, and track which products are accelerating between runs. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/rogelio.perez/aliexpress-product-trends-scraper.md
- **Developed by:** [Rogelio Perez](https://apify.com/rogelio.perez) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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 Product Trends Scraper: Prices, Daily Sales & Best Sellers

**AliExpress Product Trends Scraper** is an AliExpress scraper that turns any keyword into a spreadsheet of products with prices, **exact sold counts** and **daily sales**. Use it for dropshipping product research and for finding best-selling and fast-growing AliExpress products. No AliExpress account, login or API key needed.

Most AliExpress scrapers return a list of products with a rounded "10,000+ sold" label. This one tells you **how fast each product is actually selling**, so you can tell a product that took two years to reach 12,000 orders from one that reached 9,000 in four weeks.

### What can this AliExpress scraper do?

- **Scrape AliExpress search results** by keyword, or paste any AliExpress search or category URL.
- **Get exact order counts**, not just "10,000+ sold" labels.
- **See daily sales for every product from the very first run**, based on its launch date.
- **Track sales growth between runs.** Schedule the Actor daily and see which products are accelerating.
- **Filter** by price, rating, minimum sales, daily sales, free shipping and AliExpress Choice.
- **Sort** by best selling, newest, price or relevance, and rank the output by daily sales.
- **Choose your market:** prices, currency and availability for the United States, United Kingdom, Canada, Australia, Germany, France, Spain, Italy and the Netherlands.
- **Export** to JSON, CSV, Excel, XML or HTML, or send results to Google Sheets, Make, Zapier or any webhook through Apify integrations.

### Why use this AliExpress scraper?

| | Typical AliExpress scraper | AliExpress Product Trends Scraper |
|---|---|---|
| Sold count | Rounded label ("10,000+ sold") | Exact count, plus the label |
| Daily sales | Not provided | On every product, from run one |
| Growth over time | You build it yourself | Built in: change, growth % and units per day since your last run |
| Find winners | Sort by total orders (favors old products) | Filter and sort by daily sales |
| Speed and cost | Often a browser | Plain HTTP, about 60 products per page |

### What data can you extract from AliExpress?

| Field | Description |
|---|---|
| `productId`, `url`, `title`, `imageUrl` | Product identity |
| `price`, `currency`, `priceFormatted` | Current sale price in your chosen currency |
| `originalPrice`, `discountPercent` | Price before discount and the discount |
| `rating` | Star rating from 0 to 5 |
| `soldCount`, `soldCountExact`, `soldText` | Total units sold, whether it is exact, and AliExpress's own label |
| `dataComplete` | `true` when AliExpress returned both the sales data and a price. Incomplete products are skipped unless you ask for them |
| `listedAt`, `ageDays` | Launch date and product age |
| `lifetimeSoldPerDay` | Average units per day since launch |
| `dailySales`, `dailySalesBasis` | Units per day, and whether it is measured `since_last_run` or `since_launch` |
| `trend`, `isNew`, `soldDelta`, `soldGrowthPct`, `soldPerDay` | Sales change since your previous run |
| `previousSoldCount` | Sold count at your previous run |
| `freeShipping`, `isChoice`, `isSponsored`, `tags` | Badges shown on the search result |
| `query`, `page`, `position`, `scrapedAt` | Where and when the product was found |

### How to scrape AliExpress products

1. Click **Try for free** and open the **Input** tab.
2. Enter one or more **search keywords**, for example `led strip lights`, or paste AliExpress search URLs.
3. Pick your **ship-to country** and a **sort order**. For proven sellers use *Best selling*. To find newer products use *Newest*.
4. Set **Max products**. Each product is one billed result, so this caps your cost.
5. Click **Start**. Download the results from the **Output** tab in JSON, CSV or Excel.

### Find winning products with daily sales

Total orders favor products that have been listed for years. **Daily sales** is the fairer signal.

- **First run:** `dailySales` is the average since the product launched (`dailySalesBasis: since_launch`). A product launched four weeks ago with 9,000 orders shows about 320 a day, while a two-year-old product with 12,000 orders shows about 14 a day.
- **Later runs:** once at least a day has passed, `dailySales` becomes the real growth since your last run (`dailySalesBasis: since_last_run`), with `soldDelta`, `soldGrowthPct` and a `trend` of `rising` or `flat`. Under a day apart, you still get the change, but `dailySales` stays on the since-launch average.
- **Why a day or more:** AliExpress updates order counts with a delay. In a live 12-hour comparison most products had not changed yet, and a few counts were corrected slightly downward (shown as `flat`). Daily or weekly runs give meaningful growth.

**To run a daily watchlist:** create a Schedule in Apify, keep the same keywords, country and **Tracking ID**, and set *Output order* to *Daily sales*. Set **Minimum daily sales** (for example `20`) to receive only products that are selling fast.

### Input

| Field | Description |
|---|---|
| Search keywords / URLs | What to search. Use either or both. |
| Ship-to country, Currency | Market and currency. Currency defaults to the country's. |
| Sort by | Best selling, relevance, newest, price low to high, price high to low. |
| Max products | Total products to return across all keywords. |
| Max pages per keyword | About 60 products per page. Results run out around page 40 to 50. |
| Min / max price, Min units sold, Min rating | Filters, in the selected currency. |
| Free shipping only, AliExpress Choice only | Badge filters. |
| Include products with missing sales or price data | Off by default. See the FAQ. |
| Track sales growth, Tracking ID | Save a baseline so the next run measures growth. |
| Minimum daily sales, Output order | Keep and rank fast sellers. |
| Proxy configuration | Recommended for large runs (see tips). |

### Output example

First run for the keyword `yoga mat` (US):

```json
{
  "productId": "3256806808957451",
  "url": "https://www.aliexpress.com/item/3256806808957451.html",
  "title": "Yoga Mat Pilates Fitness Mat 3/4/6mm Thicknes Non Slip Yoga Cushion Travel Fitness Exercise Pad for Women Home Gym Floor Workout",
  "price": 5.79,
  "currency": "USD",
  "priceFormatted": "US $5.79",
  "rating": 4.9,
  "soldText": "10,000+ sold",
  "soldCount": 12400,
  "soldCountExact": true,
  "listedAt": "2024-05-16",
  "ageDays": 887.4,
  "lifetimeSoldPerDay": 13.97,
  "dailySales": 13.97,
  "dailySalesBasis": "since_launch",
  "trend": "new",
  "isNew": true,
  "isChoice": true,
  "freeShipping": false,
  "query": "yoga mat",
  "page": 1,
  "position": 1
}
```

A day or more later, the same product also carries its growth, for example `"previousSoldCount": 12280, "soldDelta": 120, "soldGrowthPct": 0.98, "soldPerDay": 60, "trend": "rising", "dailySalesBasis": "since_last_run"` (illustrative numbers).

### How much does it cost?

You pay per product returned. See the **Pricing** tab for the current price. Apify platform usage is included. Use **Max products** to cap what a run can cost, and Apify's maximum-cost-per-run setting as a second safety limit.

### Tips for best results

- **Use a proxy for big runs.** AliExpress slows down a single IP after roughly 10 to 20 pages, first by returning products without their sales data and then by blocking. With Apify Proxy enabled, the Actor switches IP automatically and finishes large runs. Without one, a run returns what it collected before the slowdown and says so.
- **Keep keywords, country and sort the same between runs** so growth is comparable. AliExpress reorders results from request to request, so a product may be *new* to a run simply because it moved into the pages you scraped. Scrape enough pages to cover your niche.
- **Use a different Tracking ID for each watchlist or niche.**
- **To find new winners,** sort by *Newest* and set a *Minimum daily sales*. The *Newest* sort is AliExpress's own ordering and is not strictly by launch date, so use `listedAt` to be exact.

### Use cases

- **Dropshipping product research:** find products with high daily sales before the market saturates.
- **Price research:** compare price bands across categories and countries (prices shown on search results vary by session, so treat them as a snapshot).
- **Market research:** compare categories, price bands and demand across countries.
- **Supplier sourcing:** shortlist high-rated, high-volume products.

### Use it from code

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("<YOUR_USERNAME>/aliexpress-product-trends-scraper").call(run_input={
    "searchQueries": ["led strip lights"],
    "country": "US",
    "sortBy": "orders",
    "maxItems": 120,
    "minDailySales": 20,
    "outputOrder": "dailySales",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["soldCount"], item["dailySales"])
```

### FAQ

**Do I need an AliExpress account or API key?** No. The Actor reads public search pages.

**What happens if I run it with no input?** It runs a small demo (up to 20 products for `led strip lights`) so you can see the output format. Add keywords or AliExpress URLs to search for your own products.

**Is it legal to scrape AliExpress?** The Actor collects publicly visible product data. You are responsible for using it in line with AliExpress's terms and the laws that apply to you. Do not use it to collect personal data.

**How accurate is the sold count?** `soldCount` is the order count AliExpress exposes for the product at the time of the request, and `soldCountExact` tells you whether it is exact or parsed from the rounded label. It counts orders, not revenue. AliExpress refreshes it with a delay, so measure growth over a day or more.

**How reliable is the price?** It is the price AliExpress showed for that request. Search-result prices move between requests (coupons, new-shopper offers, cheapest variant), so the same product can show different prices a few hours apart. Use `price` as a snapshot, not a fixed list price.

**How many products can I get per keyword?** About 60 per page, and results run out around page 40 to 50, so roughly 2,400 to 3,000 products per keyword.

**Why do I get fewer products than Max products?** Your filters removed some, the keyword ran out of results, or AliExpress slowed the IP. The run's status message says which.

**Why were some products skipped, and what is `dataComplete`?** When AliExpress is rate-limiting an IP, it sometimes returns a product with only its title, price and image, and no sold count or launch date. Some products also show no price at all, for example when they cannot ship to your country. The Actor retries on a fresh IP and, by default, skips products that still lack sales data or a price, so you are never billed for a row without the data this Actor exists to provide. The status message tells you how many were skipped. Turn on *Include products with missing sales or price data* to keep them: they have `dataComplete: false` and the missing fields are empty.

**Does it return reviews, variants, seller details or shipping costs?** No. This Actor works from search results, which is what makes it fast and cheap. Shipping cost and delivery time are not shown on search results.

**Can I use my own proxies?** Yes. Add them under Proxy configuration.

**Something looks wrong.** Open the **Issues** tab with the keyword and settings you used. AliExpress changes its pages from time to time, and reports help keep the Actor working.

### Limitations

- Search-level data only: no variants, seller information, shipping costs or review text.
- The free-shipping filter relies on the "Free shipping" badge shown in English.
- `isSponsored` is based on the result type AliExpress reports and may miss some ads.
- Sales growth needs a previous run with the same Tracking ID and country.
- This Actor is independent and not affiliated with or endorsed by AliExpress or Alibaba Group.

# Actor input Schema

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

One product keyword per line, for example `led strip lights`. Leave this and the URLs empty to run a 20-product demo.

## `startUrls` (type: `array`):

Optional. Paste AliExpress search-result or category pages (aliexpress.com/w/wholesale-...). The page number is added automatically.

## `country` (type: `string`):

Sets the market AliExpress shows: prices, availability and the default currency.

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

Leave on Auto to use the country's default currency.

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

Best selling shows proven sellers. Newest leans toward recently listed products using AliExpress's own ordering, so check the launch date in the results.

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

Stop after this many products in total. Each product is one billed result, so this also caps your cost.

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

AliExpress shows about 60 products per page. Results run out around page 40 to 50, roughly 2,400 to 3,000 products per keyword.

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

In the selected currency.

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

In the selected currency.

## `minSold` (type: `integer`):

Keep products with at least this many orders in total.

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

Star rating from 0 to 5.

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

Keep only products that show a free-shipping badge.

## `choiceOnly` (type: `boolean`):

Keep only products in AliExpress's Choice program.

## `includeIncomplete` (type: `boolean`):

AliExpress sometimes returns a product without its sold count or launch date (usually when an IP is rate-limited) or without a price (for example when it cannot ship to your country). These are skipped by default and not billed. Turn this on to keep them; the missing fields will be empty.

## `trackMomentum` (type: `boolean`):

Saves each product's sold count so the next run can report how much it sold since. Schedule the Actor daily or weekly: AliExpress updates order counts with a delay, so short gaps show little change.

## `trackingId` (type: `string`):

Runs that share a tracking ID compare against each other. Use different IDs for different niches or watchlists.

## `minDailySales` (type: `number`):

Keep only products selling at least this many units per day. Set it to find winners, for example 20.

## `outputOrder` (type: `string`):

Sort the results by daily sales to see the fastest sellers first.

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

AliExpress throttles one IP after roughly 10 to 20 pages, so a proxy lets large runs finish. The Actor rotates IPs automatically.

## Actor input object example

```json
{
  "searchQueries": [
    "led strip lights"
  ],
  "country": "US",
  "currency": "auto",
  "sortBy": "orders",
  "maxItems": 20,
  "maxPagesPerQuery": 3,
  "minSold": 0,
  "minRating": 0,
  "freeShippingOnly": false,
  "choiceOnly": false,
  "includeIncomplete": false,
  "trackMomentum": true,
  "trackingId": "default",
  "minDailySales": 0,
  "outputOrder": "scraped",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Products with price, exact sold count, daily sales and sales trend.

# 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": [
        "led strip lights"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rogelio.perez/aliexpress-product-trends-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": ["led strip lights"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rogelio.perez/aliexpress-product-trends-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": [
    "led strip lights"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rogelio.perez/aliexpress-product-trends-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rogelio.perez/aliexpress-product-trends-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/k5dZKIrnxVHBVG6XG/builds/DdbDv8SEQylHnhnZf/openapi.json