# China Tenders API (CCGP Procurement) (`contextquarry/ccgp-china-government-procurement`) Actor

China tenders API for CCGP government procurement notices: buyers, budgets, deadlines, contacts, attachments, and source-linked JSON.

- **URL**: https://apify.com/contextquarry/ccgp-china-government-procurement.md
- **Developed by:** [乾勇 胡](https://apify.com/contextquarry) (community)
- **Categories:** Business, Lead generation, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 procurement notices

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Tenders API (CCGP Government Procurement)

Search China government tenders, CCGP procurement notices, and public-sector opportunities without
manually using 中国政府采购网. This Actor turns notices from the official
[China Government Procurement](https://www.ccgp.gov.cn/) portal into structured, source-linked JSON
for tender monitoring, market intelligence, CRM pipelines, and AI agents.

Pay only for results: **$5 per 1,000 procurement notices**. A 20-result trial costs at most $0.10.
There is no separate Actor-start charge.

### Who uses this data

- Suppliers and B2G sales teams looking for relevant Chinese public-sector opportunities.
- Market-intelligence teams tracking government demand, budgets, and purchasing organizations.
- Consultants and researchers analyzing procurement activity by sector or region.
- Data engineers and AI-agent builders who need an API instead of a manual Chinese search portal.

### What you can do

- Monitor new software, AI, equipment, construction, or service tenders.
- Find buyers, budgets, deadlines, project numbers, contacts, and downloadable attachments.
- Filter by Chinese keyword, publication date, notice type, procurement category, and region.
- Schedule recurring searches and send the dataset to an API, webhook, spreadsheet, or AI workflow.
- Preserve the official source URL for verification and downstream compliance checks.

### Quick start

For a low-cost first run, keep the default rolling seven-day date window and use:

```json
{
  "keywords": ["软件"],
  "includeDetails": true,
  "maxResults": 20
}
```

Chinese search terms produce the best recall. Useful starting keywords include `软件` (software),
`人工智能` (artificial intelligence), `信息化` (digitization), and `网络安全` (cybersecurity).

### Why this Actor

CCGP publishes a large volume of central and local procurement notices in Chinese. Its public search interface is useful for manual lookup but does not provide a simple export workflow for international data pipelines. This Actor adds:

- keyword, date, notice-type, category, and region filters;
- normalized JSON fields for buyer, agency, budget, deadlines, and project number;
- full notice text and attachment links;
- duplicate removal across keywords;
- Apify scheduling, datasets, API access, and MCP compatibility.

The Actor runs on demand: each run queries the official source using your current filters, removes
duplicates across keywords, and returns only the notices found up to your result limit.

### What each result can include

| Field group | Data |
| --- | --- |
| Identity | Stable source ID, title, official source URL, publication time, notice type |
| Opportunity | Procurement category, region, project number, normalized budget in CNY, deadline |
| Organizations | Buyer, procurement agency, buyer address |
| Contacts | Published project contact name and phone number |
| Documents | Search summary, normalized full notice text, attachment names and download URLs |
| Provenance | Collection timestamp for auditing and downstream refresh logic |

Some fields are optional because CCGP notice types and source templates differ. The stable
`sourceId` can be used to remove repeats between scheduled runs in your own database or workflow.

### Example input

```json
{
  "keywords": ["软件", "人工智能"],
  "dateFrom": "2026-07-01",
  "dateTo": "2026-07-06",
  "announcementType": "open-tender",
  "procurementCategory": "services",
  "includeDetails": true,
  "maxResults": 100
}
```

### Example output

```json
{
  "sourceId": "26874199",
  "title": "楚雄师范学院数智经管应用实训平台－软件采购项目竞争性磋商公告",
  "url": "https://www.ccgp.gov.cn/cggg/dfgg/jzxcs/202607/t20260705_26874199.htm",
  "publishedAt": "2026-07-05 14:17",
  "announcementType": "竞争性磋商公告",
  "region": "云南省",
  "buyer": "楚雄师范学院",
  "agency": "楚雄柏川工程项目管理有限公司",
  "projectNumber": "YNZC2026-C1-03889-CXBC-0025",
  "budgetCny": 860000,
  "deadline": "2026年07月17日 09:00",
  "attachments": [],
  "scrapedAt": "2026-07-06T00:00:00.000Z"
}
```

### Reliability and responsible use

CCGP rate-limits shared data-center addresses. The Actor defaults to a residential proxy, low concurrency, and at least 1.5 seconds between requests. Do not reduce the delay below the schema minimum or use the Actor to overload the source.

The output reproduces public procurement information from the official source. Users are responsible for checking the source notice, applicable law, procurement eligibility, and data-use requirements before relying on a result. This Actor is not affiliated with or endorsed by China's Ministry of Finance.

Optional fields vary by notice type and source formatting. Always use the included source URL as
the final authority before making a bid or commercial decision.

### Pricing

The Actor charges **$0.005 per emitted procurement notice**. Platform usage is included in that
event price. You are charged for returned results, up to the maximum run cost you approve in Apify.

### Automation and API access

After a successful run, use Apify to schedule the same search, download the dataset as JSON, CSV,
or Excel, call the Actor through its API, or expose it to an AI agent through Apify MCP. Date fields
may be omitted to automatically search the latest rolling seven-day window.

Example prompt for an MCP-connected agent:

> Find software and AI procurement notices published in China during the past seven days. Return
> the buyer, budget, deadline, project number, and official source URL.

### Frequently asked questions

#### Is the data official?

The Actor extracts public notices from CCGP, the official China Government Procurement portal, and
returns the original notice URL. It is an independent tool and is not endorsed by the source.

#### Which search language works best?

Use Chinese keywords for the best recall. English terms may miss notices because titles and content
are normally published in Chinese.

#### Can I monitor new tenders automatically?

Yes. Omit the date fields for a rolling seven-day search and schedule the Actor in Apify. Scheduled
runs can overlap; use the stable `sourceId` to suppress notices already processed downstream.

#### What happens when there are fewer results than my limit?

You pay only for procurement notices actually emitted. The Actor stops when it reaches the result
limit or exhausts the matching search pages.

### Developer notes

```bash
npm install
npm test
npm run build
npm run smoke:live
```

For a full local Actor run, save the JSON input as
`storage/key_value_stores/default/INPUT.json` and run `npm start`. Set
`APIFY_LOCAL_STORAGE_DIR=./storage` if your environment does not do so automatically.
The live smoke command performs one search and one detail request; set `PROXY_URL` when the
source rate-limits your network.

Pay-per-event monetization uses the `tender-result` event through `Actor.pushData`. When the user's charge limit is reached, the Actor stops before making more source requests.

# Actor input Schema

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

Chinese keywords work best. Each keyword is searched separately and results are deduplicated.

## `dateFrom` (type: `string`):

Inclusive date in YYYY-MM-DD format. Defaults to seven days ago.

## `dateTo` (type: `string`):

Inclusive date in YYYY-MM-DD format. Defaults to today.

## `announcementType` (type: `string`):

Filter by the notice type used by the CCGP search portal.

## `procurementCategory` (type: `string`):

Filter notices by goods, works, or services.

## `region` (type: `string`):

Optional Chinese province or region name used as an output filter, for example 云南 or 北京.

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

Adds budget, deadlines, project number, contacts, full text, and attachments. Slower but more useful.

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

Stop after emitting this many unique procurement notices.

## `maxPagesPerKeyword` (type: `integer`):

Maximum number of CCGP search-result pages to inspect for each keyword.

## `requestDelayMillis` (type: `integer`):

Keep this at 1000 ms or above to reduce load on the official portal.

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

Residential proxy is recommended because CCGP rate-limits shared data-center addresses.

## Actor input object example

```json
{
  "keywords": [
    "软件"
  ],
  "announcementType": "all",
  "procurementCategory": "all",
  "includeDetails": true,
  "maxResults": 100,
  "maxPagesPerKeyword": 5,
  "requestDelayMillis": 1500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

API endpoint for the run's structured procurement notice dataset.

# 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("contextquarry/ccgp-china-government-procurement").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("contextquarry/ccgp-china-government-procurement").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 contextquarry/ccgp-china-government-procurement --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=contextquarry/ccgp-china-government-procurement",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "China Tenders API (CCGP Procurement)",
        "description": "China tenders API for CCGP government procurement notices: buyers, budgets, deadlines, contacts, attachments, and source-linked JSON.",
        "version": "0.1",
        "x-build-id": "GEeoXhOsmcIw9Uavz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/contextquarry~ccgp-china-government-procurement/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-contextquarry-ccgp-china-government-procurement",
                "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/contextquarry~ccgp-china-government-procurement/runs": {
            "post": {
                "operationId": "runs-sync-contextquarry-ccgp-china-government-procurement",
                "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/contextquarry~ccgp-china-government-procurement/run-sync": {
            "post": {
                "operationId": "run-sync-contextquarry-ccgp-china-government-procurement",
                "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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Chinese keywords work best. Each keyword is searched separately and results are deduplicated.",
                        "default": [
                            "软件"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateFrom": {
                        "title": "Published from",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Inclusive date in YYYY-MM-DD format. Defaults to seven days ago."
                    },
                    "dateTo": {
                        "title": "Published to",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Inclusive date in YYYY-MM-DD format. Defaults to today."
                    },
                    "announcementType": {
                        "title": "Announcement type",
                        "enum": [
                            "all",
                            "open-tender",
                            "inquiry",
                            "negotiation",
                            "single-source",
                            "prequalification",
                            "invitation",
                            "award",
                            "correction",
                            "other",
                            "consultation",
                            "transaction",
                            "termination"
                        ],
                        "type": "string",
                        "description": "Filter by the notice type used by the CCGP search portal.",
                        "default": "all"
                    },
                    "procurementCategory": {
                        "title": "Procurement category",
                        "enum": [
                            "all",
                            "goods",
                            "works",
                            "services"
                        ],
                        "type": "string",
                        "description": "Filter notices by goods, works, or services.",
                        "default": "all"
                    },
                    "region": {
                        "title": "Region",
                        "type": "string",
                        "description": "Optional Chinese province or region name used as an output filter, for example 云南 or 北京."
                    },
                    "includeDetails": {
                        "title": "Fetch notice details",
                        "type": "boolean",
                        "description": "Adds budget, deadlines, project number, contacts, full text, and attachments. Slower but more useful.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop after emitting this many unique procurement notices.",
                        "default": 100
                    },
                    "maxPagesPerKeyword": {
                        "title": "Maximum pages per keyword",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of CCGP search-result pages to inspect for each keyword.",
                        "default": 5
                    },
                    "requestDelayMillis": {
                        "title": "Delay between requests",
                        "minimum": 1000,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Keep this at 1000 ms or above to reduce load on the official portal.",
                        "default": 1500
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy is recommended because CCGP rate-limits shared data-center addresses.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```