# JD.com 京东 Scraper - Shop Products & Buyer Reviews (`clover_folktale/jd-scraper`) Actor

Collect JD.com (京东) data without a JD account: list every product of a shop (item ID, title, link, shop name) and get the buyer reviews of any item with star score, text, purchased variant, photos, follow-up review and shop reply. No login or cookies needed. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/clover_folktale/jd-scraper.md
- **Developed by:** [Silkline](https://apify.com/clover_folktale) (community)
- **Categories:** E-commerce
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

JD Scraper reads public data from JD.com (京东), one of China's largest online retailers: it searches products by keyword, lists every product of a shop and collects the buyer reviews of any item, and returns clean, flat JSON records. For reviews you get the star score, text, review photos, the purchased variant, the follow-up review the buyer added later and the shop's public reply. It is built for sellers, brand teams, analysts and developers who need China e-commerce data without a JD account. No JD account, API keys, proxies or cookies are needed.

Pricing is pay-per-event: **$0.005 per product** (shop and search modes) and **$0.005 per review**, **$0.05 per item** in `descriptionImages` mode, plus a $0.036 start fee, charged once per run and once more for each further shop or item. 100 products of a shop or a keyword search cost about $0.54, 100 reviews about $0.54.

### What is JD.com?

JD.com (京东) is a large Chinese e-commerce company. It sells its own stock in JD self-operated shops (京东自营) and hosts third-party shops. Every product has an item ID (also called SKU), and every shop has a shop ID. Shoppers leave reviews with a star score, text, photos and sometimes a follow-up review weeks later.

### What data can you get?

The Actor has four modes, chosen with `mode`:

- `shop` (default) lists the products of shops (`type` is `product`): `itemId`, `url`, `title`, `shopId` and `shopName`. A shop listing carries only these fields.
- `search` searches products by keyword (`type` is `product`) with price, shop, image and category IDs, in JD's own result order.
- `reviews` returns the buyer reviews of items (`type` is `review`), newest first.
- `descriptionImages` returns, for each item, the images of its long description page and its spec list (`type` is `description`).

#### Product fields (mode: shop)

| Field | What it is |
|---|---|
| `itemId` | JD item ID (SKU); use it as input of `reviews` mode |
| `url` | Link to the item page on item.jd.com |
| `title` | Item title (Chinese) |
| `shopId` | Shop ID you entered |
| `shopName` | Shop name |

#### Search product fields (mode: search)

| Field | What it is |
|---|---|
| `itemId`, `url`, `title` | JD item ID, item page link and title (Chinese) |
| `price` | Listed price in CNY |
| `imageUrl` | Link to the main product image |
| `shopId`, `shopName` | The selling shop |
| `categoryIds` | JD category IDs, broadest level first |
| `isSelfOperated` | True for JD self-operated (京东自营) items |
| `reviewCountText` | Review count as JD shows it, for example `200+` |
| `installmentText`, `promoTag` | Instalment and promotion labels, when shown |
| `listedAt` | When the item went on sale, ISO 8601 UTC, when JD gives it |
| `searchKeyword`, `position` | The keyword that found it and its position in that keyword's results |

#### Review fields (mode: reviews)

| Field | What it is |
|---|---|
| `reviewId`, `productId`, `url` | IDs of the review and of the reviewed item, and the item page link |
| `text` | Review text. JD fills 此用户未及时填写评价内容 when the buyer wrote nothing |
| `score` | Star score from 1 to 5 |
| `reviewedAt` | When the review was written, ISO 8601 UTC |
| `skuColor`, `skuSize` | The purchased variant (for example colour and storage size) |
| `purchaseCount` | How many of this item the reviewer has bought, as JD shows it |
| `imageCount`, `imageUrls` | Review photos |
| `likeCount` | Likes the review got |
| `followUpText`, `followUpAt`, `followUpImageUrls` | The follow-up review the buyer added later (`null` when there is none) |
| `shopReply` | The shop's public reply (`null` when there is none) |
| `reviewerNickname`, `reviewerAvatar` | Reviewer name as JD shows it (JD masks part of most names) and avatar link |
| `reviewerIsPlus` | True for JD PLUS members |

#### Description fields (mode: descriptionImages)

| Field | What it is |
|---|---|
| `productId`, `url` | The item ID and the item page link |
| `detailImages`, `imageCount` | Links of the images in the item's long description (the product detail page), and how many |
| `specs` | The item's spec list as `{name, value}` pairs, for example model number and certification |

### How to use JD Scraper

1. Open the Actor on Apify and click **Try for free** (or **Start**).
2. Choose a **Mode**: products of shops (`shop`), a keyword search (`search`), buyer reviews of items (`reviews`) or description images and specs of items (`descriptionImages`).
3. For `search`, enter words in **Keywords**. For `shop`, enter shop IDs or shop links in **Shops**. The number in a link such as `https://mall.jd.com/index-1000000127.html` is the shop ID. For `reviews` and `descriptionImages`, enter item IDs or item links such as `https://item.jd.com/100012043978.html` in **Items**; the number in the link is the item ID.
4. Set **Max results** to the total number of records you want for the run.
5. Click **Start**, then open the **Products**, **Reviews** or **Description images** view in the dataset and export as JSON, CSV or Excel, or fetch it through the API.

The Actor also runs with an empty input: `{}` lists the products of Apple's JD flagship shop, a quick way to see the output format.

A common workflow is to list a shop's products first, then use the `itemId` of interesting products in `reviews` mode.

### Input

| Field | Type | Required | What it does | Default |
|---|---|---|---|---|
| `mode` | string | Optional | `shop` (products of shops), `search` (products by keyword), `reviews` (buyer reviews of items) or `descriptionImages` (description images and specs of items) | prefilled with `shop`; when left out, `reviews` if `items` is given, `search` if `keywords` is given, otherwise `shop`. Giving more than one of `items`, `shops` and `keywords` without `mode` is an error. |
| `shops` | array of strings | Optional | Used in `shop` mode. Shop IDs or shop links containing `mall.jd.com/index-<digits>` or `shopId=<digits>`. Products are listed shop by shop until `maxResults` is reached. | Falls back to shop 1000000127 when empty |
| `keywords` | array of strings | Optional | Used in `search` mode. Search words as typed on JD.com. Each keyword returns products in JD's order, 48 per page. | Falls back to 手机 when empty |
| `items` | array of strings | Needed for `reviews` and `descriptionImages` modes | Item IDs or item links such as `https://item.jd.com/100012043978.html`. Reviews are collected item by item, newest first, until `maxResults` is reached. In `descriptionImages` mode each item gives one record. | none |
| `maxResults` | integer | Optional | Maximum number of records (products, reviews or items) to return in total for this run, from 1 to 5000. The run stops as soon as it is reached. You are charged per record returned. | 20 |

#### Example: the products of a shop

```json
{"mode": "shop", "shops": ["1000000127"], "maxResults": 100}
```

#### Example: search products by keyword

```json
{"mode": "search", "keywords": ["蓝牙耳机"], "maxResults": 100}
```

#### Example: the newest reviews of an item

```json
{"mode": "reviews", "items": ["https://item.jd.com/100008348542.html"], "maxResults": 50}
```

#### Example: description images and specs of items

```json
{"mode": "descriptionImages", "items": ["100414360368", "https://item.jd.com/100012043978.html"]}
```

### Output example

```json
{
  "type": "review",
  "reviewId": "20183617010",
  "productId": "100008348542",
  "url": "https://item.jd.com/100008348542.html",
  "text": "此用户未及时填写评价内容",
  "score": 1,
  "reviewedAt": "2023-11-26T03:55:26Z",
  "skuColor": "黑色",
  "skuSize": "128GB",
  "purchaseCount": 0,
  "imageCount": 0,
  "imageUrls": [],
  "likeCount": 6,
  "followUpText": "垃圾，翻新机已经去手机店检查了",
  "followUpAt": "2023-11-26T03:55:26Z",
  "followUpImageUrls": [],
  "shopReply": "尊敬的客户~您好！给您带来的困扰非常抱歉。……",
  "reviewerNickname": "3***k",
  "reviewerAvatar": "https://storage.360buyimg.com/default.image/6a645f6465665f696d675f393836323131373632333134353935323236_sma.jpg",
  "reviewerIsPlus": false
}
```

```json
{
  "type": "description",
  "productId": "100414360368",
  "url": "https://item.jd.com/100414360368.html",
  "detailImages": ["https://img10.360buyimg.com/imgzone/jfs/t1/520682/3/5080/274509/6aa1a67eFd095580d/00832eefced7691e.jpg.dpg", "…"],
  "imageCount": 5,
  "specs": [{"name": "国补备案型号", "value": "MJF14CH/B"}, {"name": "认证型号", "value": "A3583"}]
}
```

```json
{
  "type": "product",
  "itemId": "100433292168",
  "url": "https://item.jd.com/100433292168.html",
  "title": "小米（MI）REDMI K100 骁龙8至尊版 10000mAh大电池 小米红米5G学生游戏手机 白色 12GB+256GB 官方标配",
  "price": 3299.0,
  "imageUrl": "https://img10.360buyimg.com/n1/jfs/t1/557174/33/2332/58607/6ae08748F4ccc35ba/00833203201d5062.jpg",
  "shopId": "1000004123",
  "shopName": "小米京东自营旗舰店",
  "categoryIds": ["9987", "653", "655"],
  "isSelfOperated": true,
  "reviewCountText": null,
  "installmentText": "6期免息",
  "promoTag": "赠品",
  "listedAt": "2026-10-27T11:03:09Z",
  "searchKeyword": "手机",
  "position": 1
}
```

```json
{
  "type": "product",
  "itemId": "100414360368",
  "url": "https://item.jd.com/100414360368.html",
  "title": "Apple Watch Series 12",
  "shopId": "1000000127",
  "shopName": "Apple产品京东自营旗舰店"
}
```

### How much does it cost?

The Actor uses pay-per-event pricing. These are the charge events:

| Event | Price (USD) | When it is charged |
|---|---|---|
| `run-start` | $0.036 | Once per run, charged when the first request to the data source succeeds, even if that request returns nothing. It is not charged when the data source fails from the start, or when your spending limit cannot cover it. Each further shop, keyword or item the run actually reaches pays one more start fee. That fee is charged before its first request and is kept even if it then fails or returns nothing. A later shop, keyword or item is only reached when the earlier ones did not fill `maxResults`. |
| `result` | $0.005 | For each product returned (`shop` and `search` modes). |
| `review` | $0.005 | For each review returned (`reviews` mode). The price is $0.005 at every membership level; Store discounts do not apply to reviews. |
| `detail` | $0.05 | For each item returned (`descriptionImages` mode) |

Worked examples:

- 10 items in `descriptionImages` mode cost 10 × $0.036 (the run's start fee and one more for each further item) + 10 × $0.05 = **$0.86**.
- 100 products from one shop cost $0.036 + 100 × $0.005 = **$0.536**. Two shops that together fill 100 products cost $0.072 + 100 × $0.005 = **$0.572**.
- 100 products of a keyword search (two pages) cost $0.036 + 100 × $0.005 = **$0.536**; each further keyword adds $0.036.
- 100 reviews of one item cost $0.036 + 100 × $0.005 = **$0.536**. An item with fewer than 100 reviews costs less, because only the reviews returned are charged.

You never pay for more than `maxResults` records, and you are never charged for records that were not delivered. The run stops by itself if your spending limit is reached.

On the free Apify plan, every run returns a sample dataset: a real result of this Actor's prefilled input, captured on the date shown in the run status, so you can see exactly what the output looks like. Your own input is not used and nothing is charged. To run your own queries, use any paid Apify plan.

### Use cases

- **Product feedback and quality monitoring**: read what buyers of your own or a competitor's item complain about, with `score`, photos and the follow-up reviews that show problems after weeks of use.
- **Catalogue tracking**: list a brand's JD flagship shop regularly and spot new item IDs.
- **Customer service benchmarking**: compare how shops answer reviews through `shopReply`.
- **Market research for cross-border sellers**: see what Chinese buyers say about a product category before you source or list it.
- **AI and data projects**: clean review text with variant, score and time for sentiment models and search.

### Integrations and API

You can start runs from your own code through the Apify API, schedule them on the Apify platform (for example a weekly review check), and send results to other tools with Apify integrations and webhooks. Results are stored in a dataset you can download as JSON, CSV or Excel.

Python example using the `apify-client` package:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("clover_folktale/jd-scraper").call(run_input={
    "mode": "reviews",
    "items": ["100008348542"],
    "maxResults": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Tips and limits

- **Reliability.** The Actor retries transient errors on its own and stops cleanly instead of failing half-way. It never charges for records it did not deliver.
- **Speed.** A shop page holds 24 products and a reviews page 10 reviews, so large runs make many requests; expect roughly 2-5 seconds per page.
- **Run size.** `maxResults` is the total for the whole run (1 to 5000, default 20). With several shops or items, records are collected one after the other until the total is reached.
- **Shop listings.** A shop listing carries the item ID, title and link only. A shop that JD does not know, or that has no products, is skipped as nothing found. A shop page with fewer than 24 products ends the listing.
- **Search.** A page holds 48 products. The next page is read only while the page before it brought at least 8 products new to the run, so a keyword with few results ends early and the number of products can be below `maxResults`. JD may return promoted items among the results. JD gives no sort or price filter here; results come in its default order.
- **Reviews.** Reviews come newest first, 10 per page. JD fills 此用户未及时填写评价内容 into `text` when the buyer wrote nothing. JD masks part of most reviewer names. An item without reviews, or an ID JD does not know, is skipped as nothing found, and the run then stops, so put items you are unsure about last.
- **Free plan.** Every run on the free Apify plan returns a stored sample dataset (a real result of the prefilled input); your own input is not used and nothing is charged. Use any paid Apify plan to run your own queries.
- **Description images.** One request per item. An item ID JD does not know is asked a few times and then skipped as nothing found; nothing is charged for it. The image links are returned as JD serves them (many end in `.dpg`).
- **Privacy.** Only public data is returned: what anyone sees on JD.com, such as shop names and the reviews with their masked reviewer names. No buyer contact data, no private shop data.

### Known limits

- Search has no sort or price filter and cannot go past what JD returns for a keyword.
- Stock and sales are not included; shop mode returns ID, title and link only, search mode adds price and shop.

### FAQ

#### Do I need a JD account, cookies or an API key?

No. You only need an Apify account to run the Actor.

#### Is this the official JD API?

No. This Actor is not affiliated with JD.com. It is an independent tool that collects public data and returns it as structured JSON.

#### Is it legal to scrape JD.com?

The Actor only returns public data that anyone can see on JD.com. It does not return private buyer data or messages. You are responsible for how you use the data and for following the laws and rules that apply to you.

#### How fresh is the data?

The data is collected live during each run.

#### Where do I find an item ID or a shop ID?

In the links: `https://item.jd.com/100012043978.html` is item 100012043978, and `https://mall.jd.com/index-1000000127.html` is shop 1000000127. `shop` mode returns the item IDs of a shop.

#### Can I search JD.com by keyword?

Yes, use `search` mode with `keywords`.

#### How many results can I get?

You can set `maxResults` up to 5000 per run. A shop with fewer products, or an item with fewer reviews, returns what exists.

#### Can I schedule runs and export the data?

Yes. You can schedule runs on Apify, start them through the API, and export the dataset as JSON, CSV or Excel.

#### Something is missing. How do I ask for it?

Missing a field or a mode? Open an issue from the Actor page and it will be looked at.

### More tools from the same developer

- [Taobao 淘宝 Tmall Product Scraper - Prices, Sales & Shops](https://apify.com/clover_folktale/taobao-scraper)
- [1688 阿里巴巴 Scraper - Wholesale Prices & Suppliers](https://apify.com/clover_folktale/1688-scraper)
- [Douyin Shop 抖音商城 Scraper - Products, Sales, Commission](https://apify.com/clover_folktale/douyin-shop-scraper)
- [Amazon Scraper - Products, Prices, Ratings & Best Sellers](https://apify.com/clover_folktale/amazon-scraper)
- [Xiaohongshu 小红书 RedNote Scraper - Notes, Comments & User IP](https://apify.com/clover_folktale/xiaohongshu-scraper)

# Actor input Schema

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

List the products of shops, read the buyer reviews of items, get the description images and spec list of items (descriptionImages), or search products by keyword (search). When left out (API calls), reviews is used if items are given, search if keywords are given, otherwise shop.

## `shops` (type: `array`):

Shop IDs or shop links such as https://mall.jd.com/index-1000000127.html (the number in the link is the ID). Products are listed shop by shop until Max results is reached. Falls back to shop 1000000127 (Apple's JD flagship) when empty.

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

Search words as typed on JD.com, for example 手机 or 连衣裙. Each keyword returns products in JD's own order, 48 per page; paging continues while pages keep bringing enough new products. Falls back to 手机 when empty. Each further keyword pays one more start fee.

## `items` (type: `array`):

Item IDs (the itemId field of shop mode) or item links such as https://item.jd.com/100012043978.html. Reviews are collected item by item, newest first, until Max results is reached. In descriptionImages mode each item gives one record: its long-description images and spec list.

## `maxResults` (type: `integer`):

Maximum number of records (products, reviews or items) to return in total for this run. You are charged per record returned.

## Actor input object example

```json
{
  "mode": "shop",
  "shops": [
    "1000000127"
  ],
  "keywords": [
    "手机"
  ],
  "maxResults": 20
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped items (JSON, CSV, Excel via the dataset API).

# 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 = {
    "mode": "shop",
    "shops": [
        "1000000127"
    ],
    "keywords": [
        "手机"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("clover_folktale/jd-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 = {
    "mode": "shop",
    "shops": ["1000000127"],
    "keywords": ["手机"],
}

# Run the Actor and wait for it to finish
run = client.actor("clover_folktale/jd-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 '{
  "mode": "shop",
  "shops": [
    "1000000127"
  ],
  "keywords": [
    "手机"
  ]
}' |
apify call clover_folktale/jd-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,clover_folktale/jd-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/RbwjPBmPNHO4d4XX9/builds/ZQB1OnKsRtMSQDL80/openapi.json