AliExpress scraper API

E-commerce · v1.1.0 · aliexpress_search

$0.001 / item

$1.00 / 1K · pay per delivered item

An AliExpress scraper API that returns items for a keyword with sale price and original price, discount percentage, star rating, orders sold, promo chips and image — billed per delivered item.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Run in dashboard See the request

$0.001 per delivered item · $2 free every month · Failed runs never billed

What it does

What an AliExpress scraper API does

AliExpress hydrates its search page from an embedded payload, which is good news: the numbers you see are in the page, not assembled by a script you would have to run. The catch is that the payload is a JavaScript literal whose outer keys are unquoted, and the item list hangs off a module id that changes between builds.

The parser cuts the payload from its first quoted key and then locates the item list by shape rather than by path, so a layout reshuffle moves the node without breaking the collector. Orders sold and discount percentage come through as AliExpress publishes them.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`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	How many items to deliver at most (1–250). You pay only for delivered items.

Outputs — 29 fields, one row per item

What one item looks like

Every delivered item carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

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.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/aliexpress_search/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/aliexpress_search/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"running shoes","country":"us","currency":"USD","max_results":60}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/aliexpress_search/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "query": "running shoes",
        "country": "us",
        "currency": "USD",
        "max_results": 60
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/aliexpress_search/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"query":"running shoes","country":"us","currency":"USD","max_results":60}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the aliexpress_search collector with query="running shoes" and country="us"

Example response

POST /v1/scraper/collectors/aliexpress_search/run

$ curl $QD/aliexpress_search/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"query": "running shoes", "country": "us", "currency": "USD", "max_results": 60}'
{ "status": "done", "count": 60,
  "results": [
    {
      "product_id": "…",
      "title": "…",
      "price": "…",
      "price_value": … } ],
  "cost": 0.06 }
# 60 items × $0.001 · nothing delivered, nothing charged

Try it

AliExpress search, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

AliExpress scraper API: from query, currency and country, QuanticData reads the AliExpress results and returns one row per item with title, price and discount_percent, at $0.001 per delivered item. — You send query and currency; the run goes out through a residential exit and comes back as items with rank, page and product_id — 29 fields on every row — and you are billed $0.001 for each item actually delivered, nothing for a run that delivers none.

$0.001 / item2,000 items on the free $2 every month

Semantic inputquery, currency, country — no URL lists

Up to 250items per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Pricing

AliExpress scraper API pricing

$0.001 per delivered item. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 2,000 items before you spend anything.

$0.001per delivered item$1 per 1,000 delivered items

2,000 itemson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people build with the AliExpress scraper API

Three shapes of work this endpoint was designed around.

Sourcing research

Compare unit price, discount and orders sold across suppliers for the same product.

Dropshipping catalogues

Collect candidate items with store, rating and shipping chips attached.

Price benchmarking

Set a floor for a category by watching what the marketplace actually charges.

AliExpress scraper API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Payload path	Hardcoded, breaks on the next build	Item list located by shape
Discount	Computed by hand from two prices	Returned as published

What people search for

Live autocomplete demand around AliExpress search, pulled with our own Keyword ideas collector.

Public demand data, and where it comes from

AliExpress publishes an affiliate/open platform API built around promotion and commission, serving the affiliate catalogue rather than the search page. For product research the gap is the orders figure and the live sale price in the position AliExpress actually served them — properties of the results page, not of a promotional catalogue.

That orders field is why this collector exists at all. Almost no marketplace publishes a cumulative units-sold number next to every listing, which makes AliExpress one of the few public sources of something close to demand data at scale. Paired with rating and store it supports genuine research rather than guesswork.

Limits, currency and the legal bit

Up to 250 items per run. The item node is located by shape rather than by a fixed path in the page's hydration payload, so an internal reshuffle at AliExpress does not silently empty your dataset. Throughput is your plan's rate limit rather than anything about the collector: 60 requests/minute on pay-as-you-go, up to 1,200 on the top tier.

Pin currency on anything you will compare over time. AliExpress quotes in the visitor's currency, so an unpinned series drifts with exchange rates and records price movement that never happened.

Collecting publicly visible data is generally lawful in most jurisdictions, and courts have repeatedly declined to treat reading a public page as unauthorised access. AliExpress's terms restrict automated access, and store names can be personal data where the seller is an individual. None of this is legal advice — get some for your actual use case.

AliExpress scraper API: the POST to the aliexpress_search collector, 60 items delivered and the bill, 60 × $0.001 = $0.06 in usage.cost_usd; zero items would cost $0. — The same call you would paste into a terminal: a Bearer key, query, currency and country in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many items arrived and usage.cost_usd is $0.06, which is 60 × $0.001. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the AliExpress scraper API.

Something else? Ask us

Can I choose the currency?

Yes — pass currency (USD, EUR…) and prices come back in it, both as text and as a number.

Are orders sold exact?

They are what AliExpress prints on the card, which is a rounded band ("1,000+ sold"). The field is returned verbatim so you can see the rounding rather than inherit a false precision.

Is there a free AliExpress scraper API?

Every account gets $2 of credit every month with no card, which is about 2,000 delivered items on this endpoint at $0.001 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.001. A run capped at 250 items — the maximum for this collector — costs $0.25 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Is the orders number reliable?

It is the cumulative figure the listing itself displays, delivered as an integer rather than a parsed display string. Treat it as the platform's own claim rather than an audited number — but it is published per listing at a scale nothing else matches, which is what makes it useful for trend work.

Will a layout change break my pipeline?

The listing data comes from a JSON payload embedded in the page, and the item node is found by its shape rather than by a hard-coded path. That is specifically to survive the reshuffles that break path-based scrapers.

Run the AliExpress scraper API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Run in dashboard

Illustration: three coloured zones of the page that is read (AliExpress results) turn into clean JSON with the fields title, price and discount_percent; 29 fields on every row.