# Taobao & Tmall Scraper — Prices, Shops & Ratings (`blueskyscraper/taobao-tmall-scraper`) Actor

Get Taobao and Tmall search results and product cards with no login: prices in CNY, shop ratings, category ids, discount type and the latest review. 12 storefronts.

- **URL**: https://apify.com/blueskyscraper/taobao-tmall-scraper.md
- **Developed by:** [BlueskyScraper](https://apify.com/blueskyscraper) (community)
- **Categories:** E-commerce, Developer tools, Agents
- **Features:** Limited permissions
- **Stats:** 10 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.68 / 1,000 search 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/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

Taobao and Tmall search results, category listings, product cards and reviews with no login and no proxy of your own: prices in CNY, Tmall vs Taobao and official-store status, brand from Taobao's own brand filter (never the shop name), pack size from the title, buyer review tags, shop ratings, the review-count label, and as many reviews as you ask for.

![Taobao and Tmall scraper input: what you fill in](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/taobao-tmall-scraper/input.png)

![Taobao and Tmall scraper output: real rows from a run](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/taobao-tmall-scraper/output.png)

### Tested head-to-head on 6 November 2026

The same keyword (狗粮) and a 20-row limit went through this Actor and four popular Taobao Actors.

| | This Actor | Others |
|---|---|---|
| Filled fields per row | 91% | 41–63% |
| Time for 20 rows | 6 s | 10–27 s |
| Price per row, Free plan | $0.0024 | $0.002–$0.006 |

### What works, measured on 5 November 2026

| Data | Status |
|---|---|
| Search by keyword | ✅ 18–20 items per request, three categories verified (dog food, cat litter, rice cooker) |
| Price | ✅ `price` and `priceOriginal` in CNY (`priceFen` for exact cents), plus `displayCurrency` of the storefront |
| Title | ✅ full title as Taobao prints it in the listing |
| Shop | ✅ `shopName`, `shopId`; card mode adds seller type, credit level, opening date, item count and 物流/服务/商品描述 ratings |
| Category | ✅ `categoryId` and `rootCategoryId` |
| Discount type | ✅ `天猫U先`, `优惠价` and the like |
| Marketing bullets | ✅ `sellPoints` from the listing |
| Item id | ✅ numeric `itemId` plus `itemIdStr` — the SEO form used in item links |
| Product card | ✅ price, location, item type (Taobao/Tmall), images, free shipping, area limit |
| Card completeness flag | ✅ `cardComplete` and `cardAttempts`: the storefront sometimes returns a thin variant, so a card is re-requested up to three times |
| Latest review | ✅ one review per card: score, text, date, buyer's SKU |
| Review count | ✅ `reviewCount` from the SEO block — Taobao prints «900+用戶購後寫下真實評論» |
| Positive rate | ✅ `positiveRate` (好評率, 0–100) when Taobao prints it |
| Tmall or Taobao | ✅ card: `platform` (`tmall` / `taobao`, from Taobao's own item type and seller type B/C). Search rows: `platformHint` from Tmall-only shop names, `platform` stays null |
| Store type and official status | ✅ `storeType` (`flagship`, `tmall_supermarket`, `authorized_store`, `multi_brand_store`, `tmall_store`, `taobao_shop`), `isOfficialStore`, `officialStatusSource` says where it came from |
| Brand | ✅ with `splitByBrand`: `brandId`, `brandName` from Taobao's brand filter, `brandSource: "taobao_brand_filter"`. Brand and shop are separate fields; a shop name is never copied into the brand |
| Pack size / format | ✅ `massLabel`, `massGrams` or `volumeMl`, `packCount`, `packFormat` read from the title (`massSource: "title"`). A title with several sizes (1.5kg/3kg/10kg) is a multi-variant listing: `massGrams` stays null and the sizes go to `massCandidates` |
| Buyer review tags | ✅ `reviewTags` \[{tag, count}] — what buyers say (价格很实惠 · 362), on search rows and cards |
| Category path | ✅ card: `categoryPath` (names) and `frontCategoryIds` — feed those ids to `categoryIds` |
| Category listing | ✅ `categoryIds` — e.g. newest products of a category every week (`sorts: ["new-des"]` + `previousDatasetId` → `isNew`) |
| Coupon | ✅ card: `hasCoupon` (a shop coupon is offered); `couponAmount` is null — Taobao shows the amount only after login |
| Review count | ✅ `reviewCountLabel` exactly as printed («1萬+», «400+»), `reviewCount` = its lower bound, `reviewCountIsExact: false`. It is a rounded label, not a count |
| Reviews | ✅ `maxReviewsPerItem`: newest reviews as `type: "review"` rows — rating, text, date (Beijing time), photos, follow-up, seller reply and the **variant the buyer bought** (`variantText`, `variant`). Up to 1 000 per product |
| Sales rank | ✅ `salesRank` with the sort order "Sales": the product's place in Taobao's sales ranking. A rank, not a number of sales |
| Sales label (月销 / 已售) | 💲 with `paidSalesAndPages`: `salesLabel` word for word as Taobao prints it, `salesLabelWindow` (`month`, `30d`, `unspecified`), `salesCountAtLeast` (from «1万+» → 10000) and `salesLabelCaveat` — a rounded label, never an exact sales count. Taobao prints it only on some products; without it `salesLabel` is null with `salesLabelReason`. Free path: no label (Taobao shows it only to logged-in visitors) |
| Result pages 2+ | 💲 with `paidSalesAndPages` + `maxPaidSearchPages` |
| Variants (SKU list) | 💲 with `includeSkuDetails`: `skus` \[{skuId, name, props, price, stock}], `skuCount`, `specValues`, `stock`, `inStock`, `reviewCountExact`, `favoriteCount`, `sevenDayReturn`. SKUs are a list inside the product row — a variant is never a product row. Free path: no SKU list (`variantsAvailable: false`) |
| Full description, specs | ⛔ only the SEO summary is public: title, price, shop, review |
| Storefront fallback | ✅ when a storefront answers with an empty page, the actor moves to the next one instead of repeating the same address; `requests.storefrontFallbacks` shows how often |
| Search pagination | ⛔ page 2 is closed to a logged-out visitor (`?page=2` is ignored, `/<keyword>_2.htm` redirects to the home page, the infinite-scroll call asks for a login). Depth comes from sort orders, storefronts and `splitByBrand` (one more page per brand), until `maxItems` is reached |
| Card by numeric item id | ⛔ the storefront answers with a generic shell — use `itemIdStr` from a search row |

Depth, measured: one keyword × 12 storefronts × 4 sort orders gave **126 unique items** for 狗粮 and 68 for 猫砂 with 24 requests.

### Modes

**`search`** — keyword in, rows out. Each row is one product: price, title, shop, category, discount type, plus `seenOn` showing which storefront and sort order surfaced it.

**`detail`** — item link in, card out. Accepts `https://world.taobao.com/item/<itemIdStr>.htm`, a bare `itemIdStr`, or a numeric id (numeric ids are rejected with an explanation, not silently dropped).

**`search` + `includeDetails`** — search, then fetch the card for every found item and merge both into one row. Billed once, at the card price.

**`categoryIds`** (in `search`) — a category listing instead of a keyword: `https://world.taobao.com/category/206507001.htm` or `206507001`. Card rows give you the ids in `frontCategoryIds`.

**`splitByBrand`** (in `search`) — after the normal search, one request per brand Taobao lists for the keyword (up to 24). Every product found that way gets its brand; you also get more products than one page.

**`maxReviewsPerItem`** — reviews for every product row (search or card), and also for a numeric item id in the card mode (the card itself does not open by numeric id, the reviews do). Each review row is billed like one search row. Reviews come in pages of 20; a last page smaller than 3 is not asked. On the Apify Free plan a run returns up to 20 review rows.

### Paid options

Both are off by default; without them the Actor works and costs exactly as before. They use a licensed data partner, so on the Apify Free plan you get 1 paid search row and 1 full card with SKUs a day (counted per account in a small key-value store `taobao-free-paid-quota`); any paid plan removes the limit. Until 24 November 2026 they already work and are billed at the regular row prices (a paid search row as a search row, a full card as a product card); from 24 November 2026 their own prices below apply.

- **`paidSalesAndPages`** — result pages 2…N+1 for each keyword (`maxPaidSearchPages`, default 3), then the popular sort for sales labels when the margin allows. A page that brings fewer than 10 new products stops the paging. Rows: `rowSource: "everyinfra_search"`, `resultPage`, `priceBasis` (`page` = shown price, `list` = crossed-out price, `promotion` = promo price).
- **`includeSkuDetails`** — the full card for every product row (and for numeric ids in the card mode). Prices of SKUs are mostly converted from USD by the source (`skuPriceBasis: "converted"`) and can differ from the page by 1–4 %.

Rows from paid options carry `provenance.via: "everyinfra"`.

### Daily panel and weekly new products

- Daily: schedule the search with your keywords, `sorts: ["", "sales-des"]`, `splitByBrand: true` and yesterday's dataset in `previousDatasetId` — you get price moves, `salesRank` and brand per product.
- Weekly new products per category: `categoryIds` + `sorts: ["new-des"]` + last week's dataset in `previousDatasetId`; `isNew: true` marks the products that were not there last week.

### Storefronts and sort orders

Twelve overseas storefronts: `my` (Malaysia), `sg`, `th`, `jp`, `kr`, `au`, `ph`, `ca`, `mo`, `nz`, `vn`, `kh`. Each has its own catalogue and its own display currency; the CNY price is present in every row regardless.

Seven sort orders: relevance, sales, price ascending, price descending, newest, bid, total score. Different sort orders return different sets of items, which is how you get past the 20-item page.

### Price tracking between runs

Pass the dataset id of a previous run as `previousDatasetId` and every row gains `previousPrice`, `priceChange`, `priceChangePercent`, `priceDirection`, `daysSincePrevious` and `isNew`.

A product card shows the price of its default variant, while a search result shows the listing's display price — often another variant. With `includeDetails` the row keeps both: `price` (card) and `searchPrice` (search). When one run has cards and the other has search rows, the change is computed on the search price (`priceComparedOn: "search"`), so a variant difference is never reported as a price drop.

### Example row

```json
{
  "type": "search",
  "itemId": "612806788548",
  "itemIdStr": "R3htMk1Qa0liK3M0TVJyWUlaQi9WZz09",
  "url": "https://item.taobao.com/item.htm?id=612806788548",
  "title": "皇家小型犬中型犬大型犬幼犬粮柯基贵宾泰迪金毛通用狗粮",
  "price": 169,
  "priceOriginal": 169,
  "priceFen": 16900,
  "currency": "CNY",
  "priceCurrency": "CNY",
  "displayCurrency": "MYR",
  "shopId": "67597230",
  "shopName": "天猫超市",
  "categoryId": "50015380",
  "rootCategoryId": "29",
  "discountType": "优惠价",
  "freeShipping": false,
  "matchScore": 4.92,
  "keyword": "狗粮",
  "region": "my",
  "seenOn": [{ "region": "my", "sort": "relevance", "position": 2 }],
  "position": 2,
  "brandId": "98907984",
  "brandName": "ROYAL CANIN/皇家",
  "brandSource": "taobao_brand_filter",
  "platform": null,
  "platformHint": "tmall",
  "storeType": "tmall_supermarket",
  "isOfficialStore": true,
  "reviewTags": [{ "tag": "活动价格划算", "count": 4 }],
  "massLabel": null,
  "salesRank": null,
  "salesLabel": null,
  "provenance": {
    "source": "taobao",
    "canonicalUrl": "https://world.taobao.com/item/R3htMk1Qa0liK3M0TVJyWUlaQi9WZz09.htm",
    "checksum": "sha256:73ae8db1",
    "collectedAt": "2026-11-06T01:54:22.037Z"
  }
}
```

A card row (`type: "detail"`) adds `platform`, `storeType`, `categoryPath`, `hasCoupon`, `reviewCountLabel`, `reviewTags`, `shop`, `images`, `location`, `itemType`, `latestReview` (with `variant`), `payments`, `card`.

A review row:

```json
{
  "type": "review",
  "itemId": "699787756327",
  "reviewId": "3366552192881670",
  "rating": 5,
  "ratingScale": 5,
  "postedAt": "2026-11-09T22:07:00+08:00",
  "variantText": "香味:【茉莉味】混合猫砂2.5kg*6包（共30斤）",
  "variant": { "香味": "【茉莉味】混合猫砂2.5kg*6包（共30斤）" },
  "text": "该用户觉得商品非常好，给出5星好评",
  "images": [],
  "reviewSource": "everyinfra"
}
```

### Free rows

Rows of type `error`, `warning` and `notice` are never charged: an empty input, a numeric id that cannot open a card, a card that came back without product data, a storefront that refused. You always see why a row is missing instead of getting silence.

### Price

Pay per event, no subscription.

| Event | Free | Bronze | Silver | Gold |
|---|---|---|---|---|
| Search row (and each review row) | $0.0024 | $0.00216 | $0.00192 | $0.00168 |
| Product card row | $0.0048 | $0.00432 | $0.00384 | $0.00336 |
| Run start | $0.009 | $0.009 | $0.009 | $0.009 |
| Paid search row (`paidSalesAndPages`) — from 24 Nov 2026; before that billed as a search row | $0.0045 | $0.0045 | $0.0045 | $0.0045 |
| Full card with SKUs (`includeSkuDetails`) — from 24 Nov 2026, replaces the row's own price; before that billed as a product card | $0.015 | $0.015 | $0.015 | $0.015 |

### Notes

The actor reads overseas storefronts of the same platform, which serve product data publicly. Prices, titles and shop ratings are product facts; reviews are user-generated content (author names come masked by Taobao) — use them accordingly. Reviews beyond the one on the public card come from a licensed data partner. The storefront rate is throttled by `requestDelaySecs`, default half a second between requests.

### FAQ

**Do I need a login, cookies or my own proxy?** No. Paste your input and press Start.

**How do I use the data elsewhere?** Export the dataset as JSON, CSV or Excel, schedule the Actor, or call it through the Apify API, n8n, Make and the Apify MCP server for AI agents.

**What if there is no data for my input?** You get a free row with type `error` or `notice` that explains why. Data rows are the only rows you pay for, plus the small run start fee.

**Something looks wrong?** Open an issue on the Issues tab with the run link. We read every one.

### You might also like

| Actor | What it does |
|---|---|
| [1688 Scraper](https://apify.com/blueskyscraper/1688-scraper) | The wholesale side of the same market: 1688.com factory prices, MOQ and suppliers, search in English |
| [1688 Product Details Scraper](https://apify.com/blueskyscraper/1688-product-details-scraper) | Full 1688 product pages: variants with images, specs, stock, weight |
| [1688 Image Search Scraper](https://apify.com/blueskyscraper/1688-image-search-scraper) | Find the 1688 factory listings behind any product photo |
| [Alibaba Scraper](https://apify.com/blueskyscraper/alibaba-scraper) | Alibaba.com products, suppliers and buying requests |

# Actor input Schema

## `mode` (type: `string`):

Search: price, shop, store type, category, buyer review tags and pack size from the title for each result. Product cards: Tmall or Taobao, official store status, category path, coupon flag, shop ratings, review count label and the latest review for items found by search.

## `keywords` (type: `array`):

Keywords for the search mode, in Chinese (狗粮) or English (dog food). Each keyword costs one request per selected storefront and sort order. Leave empty if you only use category ids.

## `itemIds` (type: `array`):

For product cards. Takes a link like https://world.taobao.com/item/<itemIdStr>.htm or the itemIdStr itself. A plain numeric id does not open a card, because Taobao answers with an empty shell: use itemIdStr from a search row.

## `categoryIds` (type: `array`):

Taobao storefront categories instead of (or next to) keywords: a link like https://world.taobao.com/category/206507001.htm or the number itself. A product card gives you these ids in frontCategoryIds. With the sort order "Newest first" and a previous run's dataset this is the weekly list of new products per category (isNew).

## `includeDetails` (type: `boolean`):

In the search mode, also load the card of every item found: warehouse, Taobao or Tmall, shop ratings, latest review, all photos. The row is charged as a product card.

## `splitByBrand` (type: `boolean`):

Also search every brand Taobao itself lists for the keyword (up to 24, Taobao's own brand filter). Products found this way get brandId and brandName from Taobao — the brand, never the shop name — and you get more products than one result page. One extra request per brand; rows are charged as usual.

## `maxReviewsPerItem` (type: `integer`):

0 = no reviews. Otherwise up to this many of the newest reviews for every product row, each as its own row (type "review") right after the product: rating, text, date, photos, the variant the buyer bought, seller reply. Each review row is charged like one search result. Asked in pages of 20; a last page smaller than 3 reviews is not asked. On the Apify Free plan: up to 20 review rows per run.

## `paidSalesAndPages` (type: `boolean`):

Off by default. Adds Taobao result pages 2, 3… for each keyword and, when the margin allows, the popular sort — the only place where Taobao prints a sales label (月销 / 已售), copied word for word into salesLabel with salesCountAtLeast and a caveat that it is a rounded label, not a count. These rows cost $0.0045 each (event sales-search-item); a product you already got for free that gains a sales label becomes such a row. Available from 24 November 2026, not on the Apify Free plan.

## `maxPaidSearchPages` (type: `integer`):

How many paid pages (from page 2) per keyword. A page that brings fewer than 10 new products stops the paging.

## `includeSkuDetails` (type: `boolean`):

Off by default. Every product row gets the full card: all SKUs (variants) as a list inside the product with price and stock each, total stock, exact review count, favourites, 7-day return, and — when Taobao gives them — sales, brand, attributes, weight and coupon price. Works for numeric item ids too. Each such row costs $0.015 (event item-sku-detail) instead of its usual price. Available from 24 November 2026, not on the Apify Free plan.

## `regions` (type: `array`):

Overseas Taobao storefronts. Each has its own catalog and display currency; the price in yuan is always there. More storefronts give more unique items, and each one is a separate request.

## `sorts` (type: `array`):

Taobao gives a logged-out visitor only the first result page (18–20 items) for each request; page 2 is closed. Different sort orders show different items, so several sort orders — plus storefronts and "Split results by brand" — are the way to go deeper. With "Sales (highest first)" every row gets salesRank: its place in Taobao's sales ranking (a rank, not a sales count).

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

The upper limit on rows. One storefront request gives 18-20 items, so the Actor adds more storefronts and, if you did not choose a sort order, more sort orders until this number is reached.

## `previousDatasetId` (type: `string`):

Dataset ID of an earlier run. Adds previousPrice, priceChange, priceChangePercent, priceDirection, daysSincePrevious and isNew to every row, so you see how the price moved between runs.

## `requestDelaySecs` (type: `number`):

Pause between storefront requests. 0.5 seconds is polite and not slow.

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

Usually not needed. Set it only if a storefront starts refusing your address.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "狗粮"
  ],
  "includeDetails": false,
  "splitByBrand": false,
  "maxReviewsPerItem": 0,
  "paidSalesAndPages": false,
  "maxPaidSearchPages": 3,
  "includeSkuDetails": false,
  "regions": [
    "my"
  ],
  "sorts": [
    ""
  ],
  "maxItems": 50,
  "requestDelaySecs": 0.5
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

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

No description

# 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 = {
    "keywords": [
        "狗粮"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("blueskyscraper/taobao-tmall-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 = {
    "keywords": ["狗粮"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("blueskyscraper/taobao-tmall-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 '{
  "keywords": [
    "狗粮"
  ],
  "maxItems": 50
}' |
apify call blueskyscraper/taobao-tmall-scraper --silent --output-dataset

```

## MCP server setup

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