Collectors · E-commerce

AliExpress scraper API in Python

AliExpress listings — sale price, discount, orders, store and rating. One POST from Python with query, rows back as JSON with 29 fields, $0.001 per delivered item. No proxies or parsers to maintain.

Get an API key See the collector

A Python requests snippet that posts { — A Python requests call to the aliexpress_search collector returns one dict per item, at $0.001 each.

First call

Install, call, read the rows.

pip install requests

The only dependency.

import os, requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/aliexpress_search/run",
    headers={"Authorization": f"Bearer {os.environ['QD_API_KEY']}"},
    json={
        "query": "running shoes",
        "country": "us",
        "currency": "USD",
        "max_results": 60,
    },
    timeout=120,
)
r.raise_for_status()
run = r.json()["payload"]
print(run["count"], "rows,", run["cost"]["usd"], "USD")
for row in run["results"]:
    print(row.get("product_id"), row.get("title"), row.get("price"), row.get("price_value"))

Python: one AliExpress search run (Scarpe (USD)), printing product_id, title, price, price_value

The key comes from an environment variable, never from the code. The run answers in the same request when it finishes in time; payload.results holds the rows and payload.cost what they cost.

Request parameters

What the collector takes.

Input of the AliExpress search collector
Parameter	Type	Required	Meaning
`query`	string	yes	What to search, e.g. "running shoes".
`currency`	string	no	Price currency, e.g. USD or EUR.
`country`	string	no	ISO 3166-1 alpha-2 code — picks the local site AND the proxy exit (default us).
`max_results`	integer	no (default 30)	How many items to deliver at most (1–250). You pay only for delivered items.

Response fields

29 fields per item.

Fields of each row (item)
Field	Type	What it holds
`rank`	integer	1-based position across pages.
`page`	integer	Search page the row came from.
`product_id`	string	AliExpress product id.
`title`	string	Item title.
`price`	string, nullable	Sale price as shown.
`price_value`	number, nullable	Numeric sale price.
`currency`	string, nullable	Currency code.
`original_price`	string, nullable	Pre-discount price.
`discount_percent`	number, nullable	Discount as a percentage.
`rating`	number, nullable	Star rating (1–5).
`orders`	string, nullable	Orders sold as shown ("1,000+ sold").
`store`	string, nullable	Store name.
`store_url`	string, nullable	Store URL.
`ships_from`	string, nullable	Shipping selling point when present.
`selling_points`	string[]	Promo chips on the card.
`image`	string, nullable	Image URL.
`url`	string	Item URL.
`original_price_value`	number, nullable	Numeric pre-discount price.
`orders_count`	integer, nullable	Exact units sold when the listing reports it.
`delivery`	string, nullable	Delivery or shipping line shown on the card.
`delivery_date_min`	string, nullable	Earliest estimated delivery date (YYYY-MM-DD).
`delivery_date_max`	string, nullable	Latest estimated delivery date (YYYY-MM-DD).
`free_shipping`	boolean	True when the card advertises free shipping.
`choice`	boolean	True for AliExpress Choice items.
`sponsored`	boolean	True for paid placements.
`sku_id`	string, nullable	SKU the displayed price belongs to.
`category_id`	string, nullable	AliExpress leaf category id.
`listed_at`	string, nullable	Listing date (YYYY-MM-DD).
`images`	string[]	Gallery image URLs.

Add ?format=csv to the runs endpoint to get the same rows as CSV.

Long runs

Run in the background, then poll.

A run that needs more time can go to the background: send "async": true, get 202 with the run id, and poll the runs endpoint until the status is done. Reading a run is free.

import os, time, requests

H = {"Authorization": f"Bearer {os.environ['QD_API_KEY']}"}
r = requests.post("https://api.quanticdata.io/v1/scraper/collectors/aliexpress_search/run", headers=H,
                  json={**{"query":"running shoes","country":"us","currency":"USD","max_results":60}, "async": True}, timeout=30)
run_id = r.json()["payload"]["run_id"]
while True:
    run = requests.get(f"https://api.quanticdata.io/v1/scraper/collectors/runs/{run_id}", headers=H, timeout=30).json()["payload"]
    if run["status"] in ("done", "failed"):
        break
    time.sleep(5)
print(run["status"], run["count"])

Python: background run and polling

Errors

What can come back, and what is billed.

Collector run errors
Status	Meaning	Billed
`400`	The input does not match the collector (`payload.errors`)	No
`401`	Missing or wrong API key	No
`402`	Balance and free credit do not cover the run: top up	No
`422`	The input can never resolve; retrying the same input cannot help	No
`424`	The run failed at the source (blocked, timed out, layout changed); safe to retry	No
`429`	Rate limit or a per-account brake; wait for `Retry-After`	No

Only delivered rows are billed: a run that delivers nothing costs nothing.

Price

$0.001 per delivered item.

What AliExpress search rows cost at list price
Rows	Cost
1	$0.001
1,000	$1.00
10,000	$10.00

Up to 250 items per run; split larger jobs into several runs. The $2 free credit every month covers about 2,000 items. No subscription; paid tiers lower the unit price. All collector prices: collector pricing.

Before you run it

Questions developers ask

Is there a free AliExpress search API?

Every account gets $2 of free usage each month, about 2,000 items of this collector at $0.001 each, with no card.

Do I have to handle proxies, retries or blocks?

No. The collector runs on our network and handles them; a run blocked at the source returns 424 and is not billed.

How many rows can one run return?

Up to 250 items per run (the max_results input, where the collector has one).

Can an AI agent run it?

Yes: the MCP server exposes it as the run_collector tool, with the same input and price. See the MCP server.

Run it on the free credit.

Create an API key, export it as QD_API_KEY and run the example. $0.001 per delivered item, no subscription.

Get an API key AliExpress scraper API