# Taobao Scraper \[$1/1K💰] | Tmall Prices | Shops | SKUs (`ahmed_jasarevic/taobao-tmall-fast-scraper`) Actor

Scrape Taobao and Tmall products by keyword, category or URL: prices in CNY, shop scores, category paths and SKUs. Search in English or Chinese, export to JSON or CSV.

- **URL**: https://apify.com/ahmed_jasarevic/taobao-tmall-fast-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 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/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 & Tmall Fast Scraper – Product Prices, Shops & SKUs

Extract **Taobao and Tmall products** by keyword, category or URL: title, price in CNY, original price, shop name, seller type, credit level, category path, ship-from location, review counts and optional SKUs with stock. Keyword or category search, Chinese or English. **$1 per 1,000 products, $2 per 1,000 product details.**

### What Can You Do With Taobao & Tmall Data?

- **China price benchmarking** – compare shelf prices for the same product category across Taobao and Tmall
- **Cross-border sourcing** – shortlist products and suppliers before contacting a shop
- **Category and shelf monitoring** – track price bands, discount labels and new listings in a niche
- **Competitor shop research** – shop name, seller type, credit level, catalogue size and shop scores
- **Product catalogue building** – item ids, images, category paths and URLs for a merchandising database
- **SKU-level price comparison** – variant prices and stock when the product page exposes them

### How It Works

![How the Taobao & Tmall Fast Scraper works: from a keyword to structured product rows with shop data.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-taobao-tmall-fast-scraper.webp)

The Actor collects publicly available Taobao and Tmall product data and normalizes it into one schema. Provide keywords, category IDs or product URLs; it reads the published search and product pages, then writes one row per product.

- Keyword and category searches cover the public results shown for each query.
- `scrapeDetails` adds shop scores, seller type and catalogue size.
- `includeVariants` adds SKU prices and stock when the product page publishes them.
- Prices are in CNY, with HKD and TWD where regional pricing is shown.

### Scrape Taobao And Tmall Product Data

This Actor focuses on the product data that Taobao and Tmall publish, so a run stays fast and lightweight. It avoids account requirements for search and returns the fields that are publicly visible.

The trade-off is scope: public search pages expose a limited number of results and some fields are hidden. The Actor broadens coverage across keywords and categories rather than claiming full pagination.

### Prices In CNY, HKD And TWD

`price` is the current price in yuan, `originalPrice` the struck-through list price when the page shows one, and `discountLabel` the promotion text. Where the keyword page exposes regional pricing, `priceHKD` and `priceTWD` are filled; otherwise they are `null`.

`priceMin` and `priceMax` filter in yuan after parsing. Products with no price are kept rather than dropped, so a strict range still surfaces listings whose price the page did not show.

### Shop Data, Category Path And Ship-From Location

The `shop` object is the part most sourcing teams actually need: `shopName`, `sellerType` (B for brand/Tmall-style, C for individual), `creditLevel`, `openedAt`, `itemCount` and `ratings[]` with shop scores such as 商品描述. `categoryPath` gives the breadcrumb, `location` the ship-from city, and `rank` the position in the keyword list.

`platform` distinguishes `taobao` from `tmall`. `tmallOnly` keeps Tmall rows, but because platform is only certain after the product page is read, it requires detail collection and can return fewer items than `maxItems`.

### Fields Taobao Does Not Publish Publicly

Sales counts, review counts, positive-review rates and SKUs are frequently absent from 2026 public pages. The actor returns `null` or an empty array for those fields rather than guessing. If you need `soldText`, `reviewCount` or `positiveRate`, treat them as opportunistic: expect `null` on most rows.

### Input – Configure A Product Search

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | array | No | — | Product URLs, bare item ids, or keyword/category page URLs |
| `searchQueries` | array | No | — | Chinese or English keywords; each search broadens coverage until `maxItems` is reached |
| `searchSort` | string | No | `relevance` | `relevance`, `sales`, `price_desc` |
| `tmallOnly` | boolean | No | `false` | Keep Tmall only; requires detail collection, may return fewer items |
| `translateKeywords` | boolean | No | `true` | English keywords translated before searching; `sourceQueryOriginal` keeps the input |
| `categoryIds` | array | No | — | Taobao category ids; about 20 products each |
| `scrapeDetails` | boolean | No | `true` | Collect the product page for shop scores, seller id and catalogue size |
| `includeVariants` | boolean | No | `false` | Best-effort SKU prices and stock when published |
| `maxItems` | integer | No | `100` | Upper bound on product rows, not a guarantee |
| `priceMin` / `priceMax` | integer | No | — | Price filter in CNY; products with no price are kept |
| `maxConcurrency` | integer | No | `16` | Parallel operations. Lower values keep large runs reliable |
| `proxy` | object | No | US | Standard Apify proxy configuration. Recommended for reliable runs |

### Output – Product Fields

| Field | Type | Description |
|---|---|---|
| `itemId` | string | Taobao/Tmall product id |
| `platform` | string | `taobao` or `tmall` |
| `title` | string | Product title |
| `price`, `originalPrice` | number | Current and list price in CNY |
| `priceHKD`, `priceTWD` | number | Regional prices when the page exposes them |
| `discountLabel` | string | Promotion text |
| `soldText`, `reviewCount`, `positiveRate` | string / number | Usually `null` on public 2026 pages |
| `location` | string | Ship-from city |
| `categoryPath` | array | Breadcrumb categories |
| `imageUrl` | string | Main image |
| `shop` | object | `shopId`, `shopName`, `sellerType`, `creditLevel`, `openedAt`, `itemCount`, `ratings[]` |
| `variants` | array | `skuId`, name, price, stock, availability, image (optional) |
| `variantPriceMin`, `variantPriceMax` | number | SKU price range |
| `source`, `sourceQuery`, `rank` | string / number | How the row was found and its position |
| `url`, `scrapedAt` | string | Product URL and ISO timestamp |

### Example Input – English Keyword, Under 300 CNY

```json
{
  "searchQueries": ["wireless earbuds"],
  "priceMax": 300,
  "maxItems": 60,
  "scrapeDetails": true,
  "includeVariants": false,
  "tmallOnly": false
}
```

### Example Output – One Product Row

```json
{
  "type": "product",
  "itemId": "1079352038299",
  "platform": "tmall",
  "title": "Wireless earbuds 2026",
  "price": 118,
  "originalPrice": null,
  "currency": "CNY",
  "priceHKD": 140.15,
  "soldText": null,
  "location": "Shanghai",
  "categoryPath": ["Home", "Audio", "Headphones"],
  "shop": { "shopName": "Audio Flagship Store", "sellerType": "B", "creditLevel": 19, "itemCount": 1685 },
  "variantCount": 0,
  "source": "keyword",
  "sourceQuery": "蓝牙耳机",
  "rank": 1,
  "url": "https://detail.tmall.com/item.htm?id=1079352038299"
}
```

### Export Taobao Data To JSON, CSV Or Excel And Schedule Runs

Results go to the default dataset and download as JSON, CSV, Excel or HTML. A 100-product run is fast; the main variable is network latency.

Prices move constantly, so a **daily or weekly schedule** is the useful cadence for shelf monitoring. Budget carefully: with `scrapeDetails` on (default), each product costs two events — $0.001 for the row and $0.002 for the detail — so 1,000 products is about $3, not $1.

### Related Actors

- [Google Search Scraper](https://apify.com/apify/google-search-scraper) – find brand context, reviews and English-language coverage of a Chinese product
- [Website Content Crawler](https://apify.com/apify/website-content-crawler) – pull shop pages, brand sites and spec sheets into clean text
- [Google Maps Scraper](https://apify.com/apify/google-maps-scraper) – check physical retail and distributor presence in a market
- [Blocket.se Scraper](https://apify.com/ahmed_jasarevic/blocket-se-scraper) – second-hand marketplace price comparison for European resale

### FAQ

#### Why use this Actor instead of a general-purpose web scraper?

This Actor collects the public product data directly, which keeps runs fast and lightweight.

#### Do I need a Taobao account?

No. Public keyword and category pages are available without an account. Some fields, such as full SKU variants, are not always public, so the Actor returns them when available and keeps the base row intact.

#### Why do sales counts and review counts come back null?

Taobao stopped exposing sold counts and review counts on many public pages in 2026. The actor returns `null` rather than inventing a number. Treat those fields as optional, not guaranteed.

#### Do I need a proxy?

Yes, for large or repeated runs. The default configuration uses an Apify proxy; lower concurrency helps when a broad run starts returning fewer results.

#### What does a run actually cost?

With defaults, each product triggers two events: the dataset row at $0.001 and the product-detail event at $0.002 — about $0.003 per product, $3 per 1,000. Set `scrapeDetails: false` to pay only $1 per 1,000 rows.

#### Can I get every product in a category?

No. Category pages expose a limited number of products each. Combine multiple `categoryIds` with keyword searches to widen coverage.

#### What are alternatives for Taobao data?

Official Taobao/Alibaba partner APIs require a seller or developer account and are not available for open market research. Commercial data vendors sell curated China e-commerce data. This Actor is the lightweight public-data route.

### For AI Agents & LLM Apps

Returns one row per Taobao/Tmall product with price, shop data, category path, ship-from location and optional SKUs.

Minimal working input:

```json
{ "searchQueries": ["蓝牙耳机"], "maxItems": 20 }
```

Variant — cheapest rows only, no detail pass:

```json
{ "searchQueries": ["wireless earbuds"], "priceMax": 100, "scrapeDetails": false, "maxItems": 40 }
```

Output fields: `type, itemId, platform, title, price, originalPrice, currency, priceHKD, priceTWD, discountLabel, soldText, reviewCount, positiveRate, location, categoryPath, imageUrl, shop.*, variants, variantPriceMin, variantPriceMax, source, sourceQuery, rank, url, scrapedAt`.

Behaviors an agent should know:

- **`scrapeDetails` defaults to true**, so each product also triggers a `product-detail` event — budget $0.003 per product, not $0.001.
- `maxItems` is an upper bound, not a promise: keyword coverage depends on search breadth, and category pages yield a limited number of items each.
- `tmallOnly: true` needs detail collection to confirm `platform`, so it can return fewer rows than requested.
- `soldText`, `reviewCount`, `positiveRate` and `variants` are frequently `null`/empty on public pages — never treat them as required.
- `includeVariants` is best-effort; when variants are not public, the base row is still saved.
- `translateKeywords` defaults to true; the original keyword is preserved in `sourceQueryOriginal`.
- An Apify proxy is recommended for large or repeated runs.

Billing: **$0.001 per product row** plus **$0.002 per product detail**, plus a small actor-start event.

### Legal & Compliance Disclaimer

This actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by Taobao, Tmall, Alibaba Group, or any shop listed on those platforms.

It collects publicly accessible product and search data. No login, no account, no CAPTCHA-solving service, no private data. It does not place orders, contact sellers or access buyer data.

Listings, images, titles and shop names belong to the platforms and their sellers. Users are responsible for complying with Taobao's and Alibaba's Terms of Service, with Chinese e-commerce and advertising rules where relevant, and with their own local law when they republish product content or use it commercially. Prices are snapshots in CNY and may change at any time. This section is a factual disclosure, not legal advice.

### SEO Keywords

taobao scraper, tmall scraper, taobao api, tmall api, taobao product data, tmall prices, china e-commerce data, taobao price monitoring, taobao shop data, taobao sku data, taobao keyword search, tmall product scraper, china price benchmarking, cross border sourcing data, taobao dataset, tmall shop scores, taobao alternative, china market research data

# Actor input Schema

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

Taobao/Tmall product URLs, world.taobao.com item URLs, or bare numeric item ids. Keyword and category page URLs pasted here are treated as search keywords/categories.

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

Keywords in Chinese or English. The Actor starts with the 20 public results for each keyword, then automatically queries price bands and deduplicates to fill Max products. English queries are translated to Chinese when translation is enabled.

## `searchSort` (type: `string`):

Relevance uses the public keyword page as-is. Highest price first is sorted client-side. Best selling requests Taobao's sorted page when available, but public pages no longer expose sales counts.

## `tmallOnly` (type: `boolean`):

Keep only Tmall listings. Each product page is read to determine the platform, so this requires detail scraping and may return fewer items.

## `translateKeywords` (type: `boolean`):

English keywords are translated with a free Google Translate endpoint before searching. Rows keep the original keyword in sourceQueryOriginal.

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

Taobao category ids (the number in world.taobao.com/category/<id>.htm). Each returns up to 20 products; add multiple category ids for more coverage.

## `scrapeDetails` (type: `boolean`):

For products found by keyword or category, fetch the product page to add seller id, shop scores, catalogue size, ship-from city and platform. One extra HTTP request per product; no browser.

## `includeVariants` (type: `boolean`):

Try to read the PC product page embedded SSR payload and add SKUs with price, stock, availability and image. Taobao now often shows a login wall on PC pages; when blocked, the base product row is still saved without variants.

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

Upper bound on product rows, not a guarantee. Keyword searches expand across public price bands and deduplicate to fill this limit; category pages expose about 20 products each, and literal next-page requests require a Taobao login.

## `priceMin` (type: `integer`):

Keep only products priced at or above this value, in yuan. Products with no price are kept.

## `priceMax` (type: `integer`):

Keep only products priced at or below this value, in yuan.

## `maxConcurrency` (type: `integer`):

How many HTTP requests to run at once. Default 16. Try 20-24 for faster detail scraping if your residential proxy is stable; lower it to 6-8 if Taobao or the proxy starts returning errors/CAPTCHAs.

## `proxy` (type: `object`):

Taobao serves public pages reliably only to residential IPs, preferably US. The default uses Apify Residential proxy in the US. Datacenter proxies are usually blocked. Remove the proxy only for testing from an allowed network.

## Actor input object example

```json
{
  "startUrls": [
    "https://item.taobao.com/item.htm?id=730344766230"
  ],
  "searchQueries": [
    "蓝牙耳机"
  ],
  "searchSort": "relevance",
  "tmallOnly": false,
  "translateKeywords": true,
  "categoryIds": [],
  "scrapeDetails": true,
  "includeVariants": false,
  "maxItems": 100,
  "maxConcurrency": 16,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

One dataset row per product (type=product).

# 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 = {
    "startUrls": [
        "https://item.taobao.com/item.htm?id=730344766230"
    ],
    "searchQueries": [
        "蓝牙耳机"
    ],
    "categoryIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/taobao-tmall-fast-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 = {
    "startUrls": ["https://item.taobao.com/item.htm?id=730344766230"],
    "searchQueries": ["蓝牙耳机"],
    "categoryIds": [],
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/taobao-tmall-fast-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 '{
  "startUrls": [
    "https://item.taobao.com/item.htm?id=730344766230"
  ],
  "searchQueries": [
    "蓝牙耳机"
  ],
  "categoryIds": []
}' |
apify call ahmed_jasarevic/taobao-tmall-fast-scraper --silent --output-dataset

```

## MCP server setup

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