# 🛍️ AliExpress Product Scraper — search & catalog data (`futurizerush/aliexpress-products-scraper`) Actor

Extract product data from AliExpress search results: title, sale & original prices, star rating, sold count, AliExpress Choice tag, ship-from country, images, promotion tags. Batch by keyword. No login required. For dropshipping research, catalog mapping, and price monitoring.

- **URL**: https://apify.com/futurizerush/aliexpress-products-scraper.md
- **Developed by:** [Rush](https://apify.com/futurizerush) (community)
- **Categories:** E-commerce, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 🛍️ AliExpress Product Scraper — Search Results & Catalog Data

Extract structured product data from AliExpress search results — titles, prices, star ratings, sold counts, AliExpress Choice tags, ship-from country, image URLs, and promotion badges — straight into a clean, queryable dataset.

Built for cross-border e-commerce sourcing, dropshipping research, price monitoring, and competitor catalog mapping. **No login required. No account at risk.**

---

### What you can do

- Run **batch keyword searches** across many product categories at once — phone cases, watches, electronics, fashion, home goods, anything you can search on AliExpress.
- Capture the **public product card** for every listing on the search results page: title, sale & original price, currency, star rating, sold-count badge, AliExpress Choice tag, ship-from country, image, and on-card promotion text.
- **Refine the captured listings** by minimum star rating, free-shipping promotions, or AliExpress Choice tag — listings that fail the filter are dropped before reaching the dataset, so you only review what matters.
- Export to **JSON, CSV, Excel, HTML, RSS** through Apify's standard dataset views.

---

### Input fields

| Field | What it does |
|---|---|
| 🔍 **Search keywords** | One or more keywords. Each keyword runs as a separate batch and is tagged on the output rows so you can split results downstream. |
| 📦 **Max products per keyword** | Cap how many listings to capture per keyword (10–60). |
| ⭐ **Minimum star rating** *(optional)* | Drop listings below this average rating (0–5). |
| 🚚 **Free shipping only** *(optional)* | Keep only listings whose on-card badges advertise free shipping. |
| ✅ **AliExpress Choice only** *(optional)* | Keep only listings that participate in the AliExpress Choice program (a curated-shipping label used by AliExpress; not a star-rating signal). |

Sensible defaults are pre-filled. Most users only fill in the keywords field, hit **Start**, and let it run.

---

### Output sample

A single dataset row (33 fields total — abbreviated here):

```json
{
  "product_id": "1005006302901671",
  "product_url": "https://www.aliexpress.com/item/1005006302901671.html",
  "title": "Clear Phone Case For iPhone 11 12 13 14 15 Pro Max",
  "main_image": "https://ae-pic-a1.aliexpress-media.com/kf/Se0a649a4....jpg",
  "currency_code": "USD",
  "currency_symbol": "$",
  "price_original": 2.05,
  "price_sale": 1.95,
  "price_original_display": "$2.05",
  "price_sale_display": "$1.95",
  "discount_percent": 4,
  "star_rating": 4.3,
  "sold_count": 1000,
  "sold_count_display": "1,000+ sold",
  "is_choice": false,
  "ship_from": "CN",
  "category_id": "202192403,202228401,380230",
  "spu_id": "1005006302901671",
  "sku_id": "12000036775043019",
  "is_price_power": false,
  "selling_points": ["Special offer", "Extra 2% off with coins"],
  "search_query": "phone case",
  "search_position": 1,
  "extracted_at": "2026-05-05T13:14:00+00:00"
}
````

***

### Use cases

- **Dropshipping product research** — find listings with strong sold counts and high ratings; surface the AliExpress Choice tag automatically.
- **Cross-border catalog mapping** — pull a snapshot of search-result inventory across keywords for analysis or ingest into your own product database.
- **Price-monitoring snapshots** — schedule recurring runs against the same keywords to log how prices, sale flags, and promotion badges shift.
- **Market intelligence** — measure rough demand signals (sold-count badges) per product category and ship-from country.

***

### FAQ

**Q1 — Do I need an AliExpress account?**
No. The actor reads the same public search results that any first-time visitor sees. No login, no account, no personal data involved.

**Q2 — Why is my run returning fewer items than expected?**
Public search results respond to many things — region, page load conditions, popularity of the keyword. On busy days some keywords may return fewer items, and re-running typically resolves it. If you have **Minimum star rating**, **Free shipping only**, or **AliExpress Choice only** turned on and see zero results, try relaxing those filters before re-running.

**Q3 — Why are some fields empty (e.g. `star_rating`, `sold_count`)?**
Not every listing card displays every field. Brand-new products often have no rating yet; some categories rarely show sold-count badges. The schema documents which fields are nullable. Note: when you set a **Minimum star rating**, listings without any rating yet are excluded from the output.

**Q4 — How fresh is the data?**
Each row carries an `extracted_at` timestamp recording when it was captured. Listing-card values (ratings, sold counts, promotion tags, ship-from country, etc.) reflect the snapshot at that moment and may shift between runs as AliExpress refreshes its catalog. Re-run any row whose freshness matters to your workflow.

**Q5 — Which currency and storefront does the data come from?**
By default the actor reads the AliExpress US storefront, so most rows will return USD pricing. The `currency_code` field reflects what each row was captured in; `ship_from` separately tells you the warehouse country (which is often different from the storefront). If a row occasionally returns a non-USD currency, the actor reaches a different regional cache for that listing — group by `currency_code` if you need apples-to-apples comparison.

**Q6 — Can I scrape product detail pages, reviews, or Q\&A as well?**
The current version focuses on **search-result cards** — the high-volume, high-signal surface most use cases need. Detail-page enrichment can be requested if your workflow needs it.

***

### Compliance & disclaimer

This actor extracts **public**, search-engine-indexable product data. It does not require a login, does not collect personal data, and does not interact with any logged-in surface.

You — the customer — are responsible for ensuring your use of the extracted data complies with applicable laws, the policies of the source site, and the rights of any third parties (including but not limited to image rights and trademark). The author of this actor provides the tool on an "as-is" basis and accepts no liability for downstream uses.

***

### Affiliate

If this actor or any other Apify scraper is useful to you, sharing the platform with your colleagues using this link **[apify.com/futurizerush?fpr=rush](https://apify.com/futurizerush?fpr=rush)** helps keep the actor maintained.

***

*Keywords: AliExpress, scraper, product data, e-commerce, dropshipping, sourcing, price monitoring, catalog, search results, product listing, retail, cross-border, market research, competitor analysis, Apify, Claude Code, OpenClaw, Gemini, Antigravity, Codex, ChatGPT.*

# Actor input Schema

## `queries` (type: `array`):

Product keywords to search. Multiple keywords for batch collection. Examples: phone case, watch, earphones.

## `maxProducts` (type: `integer`):

Cap the number of listings captured per keyword (10–60).

## `starRatingMin` (type: `number`):

Filter by minimum average rating (0–5). Example: 4.5 keeps only listings rated 4.5 or above. Leave empty for no limit.

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

Keep only listings whose on-card tag advertises free shipping. Listings with conditional shipping promotions (e.g. 'free shipping above a minimum order') are excluded. Note: many listings ship for free without an explicit tag, so this filter is stricter than the actual shipping cost.

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

Keep only listings that carry the AliExpress Choice label (a curated-shipping program; not a star-rating signal). Not all listings are enrolled in this program.

## Actor input object example

```json
{
  "queries": [
    "phone case",
    "watch",
    "earphones"
  ],
  "maxProducts": 60,
  "freeShippingOnly": false,
  "choiceOnly": false
}
```

# Actor output Schema

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

List of extracted public product data

## `output` (type: `string`):

Summary of this run's results

# 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 = {
    "queries": [
        "phone case",
        "watch",
        "earphones"
    ],
    "maxProducts": 60,
    "freeShippingOnly": false,
    "choiceOnly": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("futurizerush/aliexpress-products-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 = {
    "queries": [
        "phone case",
        "watch",
        "earphones",
    ],
    "maxProducts": 60,
    "freeShippingOnly": False,
    "choiceOnly": False,
}

# Run the Actor and wait for it to finish
run = client.actor("futurizerush/aliexpress-products-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "phone case",
    "watch",
    "earphones"
  ],
  "maxProducts": 60,
  "freeShippingOnly": false,
  "choiceOnly": false
}' |
apify call futurizerush/aliexpress-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=futurizerush/aliexpress-products-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🛍️ AliExpress Product Scraper — search & catalog data",
        "description": "Extract product data from AliExpress search results: title, sale & original prices, star rating, sold count, AliExpress Choice tag, ship-from country, images, promotion tags. Batch by keyword. No login required. For dropshipping research, catalog mapping, and price monitoring.",
        "version": "0.0",
        "x-build-id": "HwKBNsegQxKEQPkKW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/futurizerush~aliexpress-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-futurizerush-aliexpress-products-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/futurizerush~aliexpress-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-futurizerush-aliexpress-products-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/futurizerush~aliexpress-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-futurizerush-aliexpress-products-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "🔍 Search keywords",
                        "minItems": 1,
                        "maxItems": 50,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Product keywords to search. Multiple keywords for batch collection. Examples: phone case, watch, earphones.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProducts": {
                        "title": "📦 Max products per keyword",
                        "minimum": 10,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Cap the number of listings captured per keyword (10–60).",
                        "default": 60
                    },
                    "starRatingMin": {
                        "title": "⭐ Minimum star rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Filter by minimum average rating (0–5). Example: 4.5 keeps only listings rated 4.5 or above. Leave empty for no limit."
                    },
                    "freeShippingOnly": {
                        "title": "🚚 Free shipping only",
                        "type": "boolean",
                        "description": "Keep only listings whose on-card tag advertises free shipping. Listings with conditional shipping promotions (e.g. 'free shipping above a minimum order') are excluded. Note: many listings ship for free without an explicit tag, so this filter is stricter than the actual shipping cost.",
                        "default": false
                    },
                    "choiceOnly": {
                        "title": "✅ AliExpress Choice only",
                        "type": "boolean",
                        "description": "Keep only listings that carry the AliExpress Choice label (a curated-shipping program; not a star-rating signal). Not all listings are enrolled in this program.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
