# 🇨🇳 China Block Trades Tracker — Institutional 大宗交易 (`nexgendata/china-block-trades-tracker`) Actor

Daily A-share block trades (大宗交易) — institutional large-lot deals with price, premium/discount to market, volume, value, and buyer/seller seats. Filter by market or minimum deal size.

- **URL**: https://apify.com/nexgendata/china-block-trades-tracker.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 6 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 🇨🇳 China Block Trades Tracker (大宗交易)

Track institutional block trades (大宗交易) on the China A-share market, sourced daily from Eastmoney. Block trades are large-lot, off-order-book deals between major holders and institutions — a window into smart-money positioning that ordinary tick data hides. This actor delivers each deal with its execution price, premium or discount to the close, volume, total value, and the named buyer and seller seats (including institutional seats such as 机构专用), so you can see who is moving size in Shanghai, Shenzhen, and Beijing.

### What it extracts

Every record is one block-trade deal:

- **securityCode** — A-share ticker (e.g. 600519)
- **securityName** — listed company name
- **market** — exchange (shanghai / shenzhen / beijing)
- **tradeDate** — date the block trade settled
- **dealPrice** — negotiated execution price per share
- **closePrice** — market close on the trade date
- **premiumDiscountRatio** — deal price vs. close, as a percentage
- **dealVolumeShares** — number of shares in the block
- **dealAmountYuan** — total deal value in CNY
- **buyer** — buyer seat (e.g. 机构专用)
- **seller** — seller seat
- **stockChangePct** — the stock's price change on the day
- **dataSource** — origin of the record (Eastmoney)

### Features

- **Market filter** — pull all exchanges or scope to Shanghai, Shenzhen, or Beijing.
- **Minimum deal-size filter** — set `minDealAmountYuan` to surface only the largest institutional deals above a CNY threshold.
- **Premium / discount signal** — every deal includes its price relative to the market close, separating accumulation at a premium from forced selling at a discount.
- **Named buyer / seller seats** — see institutional seats (机构专用) and brokerage seats on both sides of each trade.
- **Result cap** — bound output with `maxResults` for predictable, cost-controlled runs.

### Input example

```json
{
  "market": "shanghai",
  "minDealAmountYuan": 10000000,
  "maxResults": 100
}
````

### Output example

```json
{
  "securityCode": "600519",
  "securityName": "贵州茅台",
  "market": "shanghai",
  "tradeDate": "2026-06-22",
  "dealPrice": 1620.00,
  "closePrice": 1685.50,
  "premiumDiscountRatio": -3.89,
  "dealVolumeShares": 30000,
  "dealAmountYuan": 48600000,
  "buyer": "机构专用",
  "seller": "中信证券股份有限公司上海分公司",
  "stockChangePct": 0.42,
  "dataSource": "eastmoney.com"
}
```

### Use cases

- **Institutional-flow tracking** — monitor which A-shares institutions are accumulating or unloading through large off-book blocks.
- **Smart-money signals** — use premium/discount and seat data to flag accumulation or distribution before it shows in price action.
- **China-equity research** — enrich fundamental coverage with a daily record of who is trading size in your watchlist names.
- **Market surveillance** — screen for unusual block activity, large discounts, or repeat institutional seats.

### How to use

1. Open the actor in Apify Console, set `market`, `minDealAmountYuan`, and `maxResults`, then click **Start**.
2. Or call it via the Apify API / client (Python, JavaScript) and read results from the run's dataset.
3. Or attach an Apify **Schedule** to run it daily after market close for a rolling history.

Results export as JSON, CSV, or Excel from the run dataset.

### Pricing

Pay-per-event: **$0.005 per run start** plus **$0.10 per block-trade record** returned. You only pay for the deals you receive — use `maxResults` and `minDealAmountYuan` to keep runs scoped.

### FAQ

**How fresh is the data?** Records reflect block trades published by Eastmoney for the trading day; run the actor after the China market close (or on a daily schedule) for the latest deals.

**What does 机构专用 mean?** It is the "institutional dedicated" seat label on A-share trade records. When it appears as buyer or seller, an institution — not an individual or named brokerage branch — was on that side of the block.

**Where does the data come from?** Directly from Eastmoney (eastmoney.com), reflected in each record's `dataSource` field.

**Can I get only the biggest deals?** Yes — set `minDealAmountYuan` to your CNY threshold and the actor returns only block trades at or above that total value.

**What output formats are supported?** Every run writes to an Apify dataset, exportable as JSON, CSV, or Excel, or readable via the API.
��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

### Related — China Market Intelligence suite

Build a full picture of Chinese markets with the rest of the suite:

- [CNINFO China Listed-Company Announcements](https://apify.com/nexgendata/china-listed-company-announcements)
- [A-Share Earnings Calendar](https://apify.com/nexgendata/a-share-earnings-calendar)
- [China Hot Stocks — Retail Attention](https://apify.com/nexgendata/china-hot-stocks-attention)
- [36Kr China Tech & Startup News](https://apify.com/nexgendata/china-tech-startup-news)
- [China A-Share IPO Subscription Calendar](https://apify.com/nexgendata/china-ipo-subscription-calendar)
- [Eastmoney China A-Shares Screener](https://apify.com/nexgendata/eastmoney-china-stock-screener)
- [Eastmoney China ETF Flow Tracker](https://apify.com/nexgendata/china-etf-flow-tracker)
- [China A-Share Insider Trades](https://apify.com/nexgendata/china-ashare-insider-trades)

# Actor input Schema

## `market` (type: `string`):

Filter by exchange.

## `minDealAmountYuan` (type: `integer`):

Only block trades at or above this total value in yuan (e.g. 10000000 = ¥10M).

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

Maximum block-trade records to return.

## Actor input object example

```json
{
  "market": "all",
  "minDealAmountYuan": 0,
  "maxResults": 100
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/china-block-trades-tracker").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/china-block-trades-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call nexgendata/china-block-trades-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/china-block-trades-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🇨🇳 China Block Trades Tracker — Institutional 大宗交易",
        "description": "Daily A-share block trades (大宗交易) — institutional large-lot deals with price, premium/discount to market, volume, value, and buyer/seller seats. Filter by market or minimum deal size.",
        "version": "1.0",
        "x-build-id": "kQJN3Tr0XZZojZ9tw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~china-block-trades-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-china-block-trades-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/nexgendata~china-block-trades-tracker/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-china-block-trades-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/nexgendata~china-block-trades-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-china-block-trades-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "market": {
                        "title": "Market",
                        "enum": [
                            "all",
                            "shanghai",
                            "shenzhen",
                            "beijing"
                        ],
                        "type": "string",
                        "description": "Filter by exchange.",
                        "default": "all"
                    },
                    "minDealAmountYuan": {
                        "title": "Min deal amount (CNY)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only block trades at or above this total value in yuan (e.g. 10000000 = ¥10M).",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum block-trade records to return.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
