# CNIPA China Patent Search — IP & Innovation Tracker (`nexgendata/cnipa-china-patent-search`) Actor

Search CNIPA Chinese patents by keyword (EN/ZH), applicant, IPC, date, status. Returns invention/utility/design patents with bilingual title+abstract, applicants, inventors, IPC, dates, family size, citations. IP attorneys, R\&D, China competitive intel. PatSnap alt.

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

## Pricing

from $50.00 / 1,000 patents

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

## CNIPA China Patent Search — IP & Innovation Tracker

**The China IP desk on tap.** Search Chinese patents filed at CNIPA — the China National Intellectual Property Administration — by keyword (English or Chinese), applicant, inventor, IPC class, filing-date range or legal status. Each record arrives with bilingual title and abstract, normalised applicant + inventor lists, IPC classes, filing / publication / granted dates, patent type (invention / utility / design), legal status, worldwide family size, and forward-citation count. Built for IP attorneys, R&D teams, competitive intelligence analysts, China-watchers, and VCs doing diligence on Chinese deep-tech.

This is the actor a single PatSnap or Patbase seat costs **$1,000+/yr** to access. Pay-per-result on Apify — no seat, no contract, no minimum commitment. Refer a friend through the [Apify Affiliate Program](https://www.apify.com/?fpr=2ayu9b) to earn 20-30% commission.

---

### Why a dedicated CNIPA actor (and not just a generic web scraper)

China has been the world's largest patent filer since 2011 and now accounts for **roughly 1.6 million patent applications per year** — more than the United States, Europe, Japan, South Korea and India combined. The CNIPA index is a strategic resource for any team doing M&A, freedom-to-operate, competitive intelligence or technology forecasting in batteries, semiconductors, EVs, solar, AI, biotech or quantum computing. Yet most of this data is hard to reach from outside China:

1. **The official CNIPA search portal is Chinese-only, requires a Chinese mobile phone number to register, and rate-limits foreign IPs aggressively.** Even with credentials, the result format is paginated HTML with embedded Chinese fonts and no machine-readable export. We bypass all of that by querying Google Patents' public XHR endpoint, which mirrors the CNIPA index in near-real-time and ships English-machine-translated titles + abstracts alongside the originals.
2. **Generic scrapers fail patent monitoring three ways: no IPC classification, no normalised applicant matching, and no patent-type discrimination.** A Huawei "utility model" on a phone-camera shim and a Huawei "invention patent" on a 6G modem live in completely different legal worlds — the first costs $400 to file and lasts 10 years with no substantive examination, the second goes through 3-4 years of examination and lasts 20 years. We return `patent_type` so your downstream pipeline routes them correctly.
3. **WIPO PATENTSCOPE, the free WIPO-run global index, is sluggish, has no clean JSON output, and times out under any non-trivial workload.** We use it as a fallback if Google Patents blocks us, but the default path is the much-faster Google Patents XHR endpoint.

What you get is a clean, dual-language, paginated CNIPA feed that drops straight into a spreadsheet, BI tool, vector store or downstream LLM. No Chinese mobile number, no PatSnap subscription, no Selenium swamp.

---

### A 60-second primer on the Chinese patent system

If you've worked exclusively with the USPTO or EPO, the Chinese IP system has some structural quirks you need to know before reading the data. CNIPA recognises **three distinct patent types** under a single application infrastructure:

- **Invention patents** (`发明专利`, fā míng zhuān lì): The closest analogue to a USPTO utility patent or EPO B-grant. Term: 20 years from filing. Requires substantive examination — novelty + inventive step + industrial applicability. Average pendency: 22 months in 2024. Publication number format: `CN<7-digit serial>A` (laid-open application) → `CN<same serial>B` (granted). Historical numbering used `CN1xxxxxx` for inventions; modern format is `CN10x` / `CN11x` / `CN12x` and so on as serials rolled over.
- **Utility models** (`实用新型`, shí yòng xīn xíng): No direct USPTO equivalent. Closest analogue is Germany's *Gebrauchsmuster* or Australia's innovation patent. Term: 10 years from filing. **No substantive examination** — CNIPA reviews only formal requirements, so grants issue in 4-6 months. Lower inventive-step bar. Covers shape, structure or combination of articles — software, processes and methods are excluded. Publication number suffix: `U`. Historical prefix: `CN2xxxxxx`. Critical for any FTO analysis in Chinese mechanical / hardware sectors because utility models can be enforced in court and routinely are.
- **Design patents** (`外观设计专利`, wài guān shè jì zhuān lì): Equivalent to a USPTO design patent or EU registered Community design. Covers ornamental shape, pattern or colour applied to an article. Term: 10 years from filing (extended from 10 to 15 years in 2021 under the new Patent Law for new applications). Publication number suffix: `S`. Historical prefix: `CN3xxxxxx`.

The actor returns the `patent_type` field for every record so you can route invention vs utility vs design downstream. The `status` field encodes the lifecycle event: `pending` (filed, not yet granted), `granted` (in force, fees paid), `expired` (term ended), `abandoned` (let lapse before grant or before annuity payment).

One detail that surprises Western IP teams: **publication of an invention application is automatic at 18 months from the filing or priority date**, exactly the same as the USPTO and EPO. So a query for `status=pending` returns patents that have been laid open but not yet granted — these are searchable but not yet enforceable. The actor captures both `publication_date` (when the application was laid open) and `granted_date` (when the patent was issued) so you can compute pendency curves.

---

### What you get

A unified CNIPA patent record stream, one row per matching Chinese patent:

```json
{
  "cn_number": "CN114725432B",
  "title_en": "Lithium-ion battery electrolyte and lithium-ion battery containing same",
  "title_cn": "锂离子电池电解液及含有该电解液的锂离子电池",
  "abstract_en": "The invention provides a lithium-ion battery electrolyte comprising a lithium salt, an organic solvent and an additive. The additive is a fluorinated sulfonate compound with the structural formula...",
  "abstract_cn": "本发明提供一种锂离子电池电解液，包括锂盐、有机溶剂和添加剂。所述添加剂为氟代磺酸酯类化合物，结构式为...",
  "applicants": ["Contemporary Amperex Technology Co., Limited", "宁德时代新能源科技股份有限公司"],
  "inventors": ["Wang Lei", "Li Ming", "Chen Wei"],
  "ipc_classes": ["H01M10/0567", "H01M10/0525", "H01M4/505"],
  "filing_date": "2022-04-18",
  "publication_date": "2022-07-08",
  "granted_date": "2023-11-21",
  "status": "granted",
  "patent_type": "invention",
  "family_size": 4,
  "citing_count": 12,
  "google_patents_url": "https://patents.google.com/patent/CN114725432B/en",
  "data_source": "google_patents_cnipa"
}
````

That single record gives you everything to:

- Track a Chinese competitor's weekly filing cadence (`applicant: "BYD"` + `date_range: month`)
- Build a quarterly CN-EV battery patent dashboard (`query: "lithium battery"` + `ipc_class: "H01M10"` + `date_range: quarter`)
- Surface freedom-to-operate risks for a US/EU product targeting the Chinese market (search by `query` of the contested feature, hard-restricted to CN jurisdiction)
- Compile an M\&A diligence patent inventory for a Chinese acquisition target (`applicant` of the target, `date_range: all`)
- Power a competitive intelligence dashboard — every new patent filed by Huawei, BYD, CATL, SMIC, BOE or DJI in the past 30 days
- Feed an LLM-grounded technology-trend report — concatenate `abstract_en` across hundreds of records and prompt the model for emerging-tech clustering
- Compute filing-velocity ratios (CN vs US) for a single technology — pair this actor's `query: "solid state battery"` output with [USPTO Patent Grants Tracker](https://www.apify.com/nexgendata/uspto-patent-grants) on the same keyword

***

### Input filters

| Input | Type | Description |
|---|---|---|
| `query` | string | Keyword search across title + abstract. Accepts English OR Chinese (mixed allowed). Google Patents indexes CNIPA records in both, so an English keyword still matches a Chinese-only patent through machine translation. |
| `applicant` | string | Partial company / university / institute name (English or Chinese, case-insensitive). Examples: `Huawei`, `BYD`, `CATL`, `宁德时代`, `Tsinghua University`, `清华大学`. |
| `inventor` | string | Partial inventor name (English or Chinese). Useful for tracking a prolific researcher across employer changes. |
| `ipc_class` | string | IPC classification code — section letter (`H`), 4-character class (`H01M`, `G06N`, `C12N`), or full subgroup (`H01M10/0525`). |
| `date_range` | enum | Filing-date window: `month` / `quarter` / `year` / `3year` / `all`. Defaults to `year`. |
| `status` | enum | Lifecycle filter: `all` / `pending` / `granted` / `expired` / `abandoned`. |
| `patent_type` | enum | Type filter: `all` / `invention` / `utility` / `design`. |
| `translate_titles` | boolean | If true, auto-translates Chinese-only titles via Google Translate. Default `true`. |
| `maxResults` | integer | Max records to push to the dataset (1–5000, default 50). |

***

### Common use cases — what to actually do with this

#### 1. China EV battery competitive intel

Run `query: "battery"` + `ipc_class: "H01M10"` + `date_range: year` and you'll get every Chinese patent in lithium-secondary-cell technology filed in the past 365 days, with `family_size` showing which ones the applicant has bothered to extend internationally (a quality signal — most Chinese filings stay domestic, so a family of 4+ usually means the applicant intends to litigate or license outside China). Filter `applicants` containing `CATL`, `BYD`, `LG`, `Panasonic`, `Samsung SDI` to see who's racing whom. Pair with [Eastmoney China Stock Screener](https://www.apify.com/nexgendata/eastmoney-china-stock-screener) to correlate patent velocity with public-market momentum on the same tickers.

#### 2. Semiconductor freedom-to-operate analysis

Run `ipc_class: "H01L21"` (semiconductor processes) + `query: "<your-contested-feature>"` + `status: granted`. The returned records are currently in force and enforceable in Chinese courts. Cross-reference applicant against your customer's CN supply chain to flag risk. The `family_size` field tells you whether the same applicant has US / EP / JP equivalents — a CN-only filing is much weaker outside China.

#### 3. M\&A diligence on a Chinese deep-tech target

Run `applicant: "<target-name>"` + `date_range: all` + `maxResults: 5000`. You'll get the target's full filing history with grant rates, technology distribution (look at the `ipc_classes` field across the corpus), inventor turnover (compare `inventors` across years) and forward-citation impact (`citing_count` is the closest thing to a quality metric — a single patent cited 30+ times in subsequent CN filings is a foundational piece of IP, while citation counts in the 0-2 range are typical for routine engineering improvements). Combine with [SEC Form 13F Tracker Pro](https://www.apify.com/nexgendata/sec-form-13f-tracker-pro) if the target has a US-listed parent.

#### 4. Technology-trend forecasting at scale

Run a weekly batch across the IPC sub-classes you care about (`G06N`, `H01M10`, `C12N15`, `H01L21`, `B82Y`) and store the JSON records in a vector database. Embed the `abstract_en` field with whatever embedding model you prefer, cluster monthly, and you have a leading indicator of emerging-tech themes inside China that typically shows up 18-24 months before it appears in Western trade press. The Chinese university and CAS institute filings in particular are a phenomenally underused early-signal source — they don't go through corporate PR pipelines.

#### 5. Inventor-network mapping

Run `inventor: "<famous-name>"` to map an inventor's career. Chinese inventors often move between commercial labs (e.g. Huawei → Xiaomi → DJI) and academic posts (CAS institutes, Tsinghua, Zhejiang University). The actor returns all applicants associated with their name in chronological order — useful for technical recruiting, advisor diligence and tracking team movements at acquired or unwound Chinese tech projects.

#### 6. AI / LLM patent racing — China vs US

Pair this actor (`ipc_class: "G06N"` + `query: "neural network"` or `large language model"`) with the [USPTO Patent Grants Tracker](https://www.apify.com/nexgendata/uspto-patent-grants) running the same `keywords` filter. The output is a side-by-side filing-velocity dashboard. As of mid-2025, China has surpassed the US in raw AI-patent count but lags in citation-weighted impact — your dashboard will show the gap closing or widening in real time.

***

### Output schema (full field list)

| Field | Type | Description |
|---|---|---|
| `cn_number` | string | CNIPA publication number, e.g. `CN114725432B`. Suffix encodes lifecycle (A=application, B=granted invention, U=utility, S=design). |
| `title_en` | string | null | English title (machine-translated by Google or auto-translated by us if missing). |
| `title_cn` | string | null | Original Chinese title. |
| `abstract_en` | string | null | English abstract excerpt (up to 1500 chars). |
| `abstract_cn` | string | null | Original Chinese abstract excerpt. |
| `applicants` | array<string> | List of applicants (English + Chinese names when both indexed). |
| `inventors` | array<string> | List of named inventors. |
| `ipc_classes` | array<string> | Up to 20 IPC classification codes. |
| `filing_date` | string | null | ISO date of CNIPA filing. |
| `publication_date` | string | null | ISO date the application was laid open (18 months post-filing for inventions). |
| `granted_date` | string | null | ISO date of grant (null for applications still pending). |
| `status` | string | `granted` / `pending` / `expired` / `abandoned` / `unknown`. |
| `patent_type` | string | `invention` / `utility` / `design` / `unknown`. |
| `family_size` | int | null | INPADOC family count — how many jurisdictions worldwide the same invention has been filed in. |
| `citing_count` | int | null | Forward citations (how many subsequent patents cite this one). |
| `google_patents_url` | string | Direct link to the Google Patents detail page. |
| `data_source` | string | Always `google_patents_cnipa` (or `wipo_patentscope` if the WIPO fallback was used). |

***

### How it works under the hood

We query Google Patents' public XHR endpoint with `country=CN` plus your filters. Google Patents mirrors the full CNIPA index — invention applications, granted invention patents, utility models and design patents — with English machine-translation of titles and abstracts available on most records dating back to ~2000. For records published before 2000 the Chinese original is still returned but the English translation may be missing; we'll auto-translate using Google Translate's public web endpoint when `translate_titles` is enabled.

Each search result is enriched with a per-patent detail-page fetch that extracts IPC classes, full applicants and inventors lists, filing/publication/granted dates, family size and citing count. Enrichment runs in parallel batches of 4 with polite jitter to stay below Google's rate-limit threshold.

If Google Patents returns HTTP 403 (rare, mostly during their occasional anti-bot tightening cycles), we fall back to WIPO PATENTSCOPE — a free, slower but reliable patent search service operated by the World Intellectual Property Organization in Geneva. WIPO's coverage of CNIPA is excellent but its result format is paginated HTML, so the fallback path returns the same fields but with slightly less detail (no family size or citing count).

***

### Pricing

Pay-per-result, no subscription, no minimums.

- **Run start:** $0.00005 per actor run
- **Per patent record:** $0.05

For comparison, a single PatSnap analyst seat is **$1,000+/yr** with limited Chinese-language coverage and per-export caps; LexisNexis PatentSight runs $30,000+/yr for the full international subscription; Patbase is enterprise-only pricing with annual commits in the high four figures. The Chinese-IP data layer in particular is a niche where Western incumbents charge a premium because translation and CNIPA-API access are hard. With this actor a 50-record competitive scan is **$2.50**, a 500-record portfolio inventory is **$25**, and a full 5,000-record CN-deep-tech sweep is **$250** — all consumable on a credit card with no procurement cycle.

***

### Related NexGenData actors

If you found this useful, you'll likely want the rest of the IP + China-intel cluster:

| Actor | What it does |
|---|---|
| [USPTO Patent Grants Tracker](https://www.apify.com/nexgendata/uspto-patent-grants) | Newly granted US patents with CPC, claims count, AI/software flags. The US-side companion to this CN actor — use both with the same keyword for a global filing-velocity dashboard. |
| [USPTO Patent Search](https://www.apify.com/nexgendata/uspto-patent-search) | Full USPTO history search (not just newly granted), useful for retrospective FTO and M\&A diligence on US-listed companies. |
| [Eastmoney China Stock Screener](https://www.apify.com/nexgendata/eastmoney-china-stock-screener) | A-share fundamentals + technical screens. Pair with this actor to correlate patent velocity with public-market momentum on the same Chinese tickers. |
| [China Trends Tracker](https://www.apify.com/nexgendata/china-trends-tracker) | Baidu Index + Weibo / Douyin trend feed for China consumer-tech and policy themes. Pair to confirm that a hot-patent theme is also seeing consumer-search momentum. |
| [JD.com Product Scraper](https://www.apify.com/nexgendata/jd-com-product-scraper) | JD.com product catalog scraper for downstream commercial-product mapping — confirm that a patented technology has actually shipped in a sellable SKU. |

***

### Apify Affiliate Program

If you're a consultant, IP attorney, VC analyst or data journalist building competitive-intel workflows on top of this actor, refer Apify with our affiliate code and earn **20% commission for the first 3 months, then 30% ongoing** on every paying user you bring in:

[**https://www.apify.com/?fpr=2ayu9b**](https://www.apify.com/?fpr=2ayu9b)

Send the link to colleagues, embed it in client decks, drop it in your newsletter. The commission flows quarterly and stacks across customers indefinitely.

***

### Comparison with incumbent China IP tools

| Capability | This actor | PatSnap | LexisNexis PatentSight | Patbase | CNIPA portal (direct) |
|---|---|---|---|---|---|
| Cost (entry) | $0.05 / record | $1,000+/yr seat | $30,000+/yr | Enterprise only | Free, but Chinese-mobile registration required |
| English machine-translation | Yes (titles + abstracts) | Yes (premium tier) | Yes | Yes | No |
| API / JSON export | Yes (Apify dataset) | Limited | Yes (paid add-on) | Yes (paid add-on) | No |
| Coverage of utility models | Yes | Yes | Yes | Yes | Yes |
| Coverage of design patents | Yes | Yes | Yes | Yes | Yes |
| Family size + citing count | Yes | Yes | Yes (premium) | Yes | No |
| Update frequency | Real-time (Google Patents mirror, ~24h delay vs CNIPA) | Weekly | Weekly | Weekly | Real-time (Chinese only) |
| Min commitment | None | 1 year | 1 year + minimum seats | 1 year | None (but registration friction) |
| Procurement cycle | Credit card, instant | 6-12 weeks | 8-16 weeks | 8-16 weeks | N/A |

***

### Smoke test result

A representative run with `query: "lithium battery"`, `maxResults: 10` returned 10 Chinese patents from leading CN battery applicants (CATL, BYD, Gotion, EVE Energy) with bilingual titles and abstracts, IPC classes anchored on H01M10/05\* (lithium secondary cells), forward-citation counts ranging from 0 to 47, and runtime ~25 seconds.

***

### Things you should know about CNIPA-specific patent behaviour

A handful of practical caveats that catch every newcomer to the Chinese IP system:

**Utility-model litigation is real and frequent.** Western IP teams routinely dismiss utility models as low-quality "junk patents" because they lack substantive examination. In China this is a costly mistake. Utility-model holders won approximately 60% of the cases they brought to Chinese courts in 2023 — a higher win rate than invention-patent plaintiffs. Damages are typically lower than invention-patent cases but injunctions are routinely granted and can paralyse a Chinese supply chain inside 8-12 weeks. When you screen a Chinese competitor with this actor, do NOT filter `patent_type: invention` out reflexively — utility models in the same portfolio carry real enforcement risk.

**Design patents now have a 15-year term.** The 2021 Patent Law amendment extended design-patent term from 10 to 15 years for applications filed on or after June 1, 2021. Older designs still expire at 10 years from filing. If your FTO analysis depends on whether a 2019-filed design is still in force, check the filing-date math carefully — the actor returns `filing_date` so you can compute term expiry directly.

**Examination at CNIPA is genuinely tough.** A common misconception is that CNIPA is a "rubber stamp" that grants anything filed. In fact, the grant rate for invention applications has hovered around 50% for the past five years, comparable to USPTO (around 60%) and EPO (around 50%). Applications that the actor returns with `status: pending` therefore have roughly even odds of ever becoming enforceable patents — useful context when projecting future portfolio composition.

**State-owned enterprises and CAS institutes file at extraordinary volumes.** The Chinese Academy of Sciences alone files 20,000+ patents per year across its 100+ research institutes. State Grid Corporation of China is consistently among the world's top 5 patent filers by volume. When you run `applicant` searches on these entities, set `maxResults` high (1,000+) and budget compute accordingly — a CAS-wide sweep can return tens of thousands of records.

**Chinese applicant names normalise inconsistently across English and Chinese.** "CATL" appears variously as `Contemporary Amperex Technology Co., Limited`, `Contemporary Amperex Technology Co Ltd`, `Ningde Amperex Technology Limited` and `宁德时代新能源科技股份有限公司` across different patent records. The actor returns both English and Chinese applicant names where indexed, but you should plan for fuzzy-matching on the consumer side. Recommended approach: lowercase, strip punctuation, take the first 12 alphanumeric characters, then match against a hand-curated alias list of the top 200 Chinese applicants.

**`citing_count` is forward citations only.** It counts how many later patents (anywhere in the world) cite this CNIPA patent. It does NOT count backward citations (which the source patent cites) or non-patent literature citations. For full citation graphs you'll need to enrich downstream against the Patstat or USPTO bulk data dumps.

***

### Changelog

- v0.1 — Initial release. Google Patents XHR endpoint primary, WIPO PATENTSCOPE fallback, bilingual title + abstract, IPC classes, family size, citing count, patent-type classification (invention / utility / design), 5 lifecycle status values, optional auto-translation for Chinese-only titles.

***

### Support

Questions, edge cases, IPC tooltip requests, or specific Chinese-applicant fuzzy-matching rules? File an issue on the actor page or email the maintainer. For commercial-scale runs (5,000+ records per refresh / 100,000+ records / month) we offer custom pricing and dedicated compute units — get in touch.

# Actor input Schema

## `query` (type: `string`):

Free-text keyword search across patent title + abstract. Accepts English OR Chinese (mixed allowed). Examples: 'lithium battery', '锂电池', 'solid state drive', 'gene editing', '半导体'. Patents.google.com indexes CNIPA records in BOTH English machine-translated title/abstract and the original Chinese, so an English keyword still matches a Chinese patent. Leave blank to pull all patents in the date window narrowed by applicant / IPC / status.

## `applicant` (type: `string`):

Restrict results to a specific Chinese applicant (company, university, institute). Accepts partial English or Chinese name (case-insensitive). Examples: 'Huawei', 'BYD', 'CATL', '宁德时代', 'Tsinghua University', '清华大学', 'CAS' (Chinese Academy of Sciences). Especially useful for monitoring a single Chinese competitor's filing cadence or running a Chinese deep-tech portfolio inventory for M\&A diligence.

## `inventor` (type: `string`):

Restrict results to patents naming a specific inventor. Accepts English or Chinese name. Examples: 'Robin Li', '李彦宏', 'Jack Ma'. Useful for following a known prolific researcher across employer changes (common in Chinese hardware / AI labs).

## `ipc_class` (type: `string`):

International Patent Classification (IPC) symbol — the global standard used by CNIPA, USPTO, EPO and WIPO. Use the section letter (e.g. 'H' = Electricity), the 4-character class (e.g. 'H01M' = batteries, 'G06N' = AI/ML, 'C12N' = micro-organisms / genetic engineering), or a full subgroup (e.g. 'H01M10/0525' = lithium secondary cells). See cpc-tooltip below. Leave blank for any class.

## `date_range` (type: `string`):

Filter by filing date at CNIPA. 'month' = trailing 30 days; 'quarter' = trailing 90 days; 'year' = trailing 365 days; '3year' = trailing 3 years (most common for competitive intel — long enough to catch quarterly cadence, short enough to filter noise); 'all' = no date filter (search the full CNIPA index back to 1985).

## `status` (type: `string`):

CNIPA patent lifecycle status. 'all' = no status filter (default). 'pending' = filed but not yet granted (the public application is published 18 months after filing). 'granted' = currently in force, fees paid. 'expired' = exclusive term ended (20 years for invention, 10 years for utility model and design from filing date). 'abandoned' = applicant let lapse before grant or before annuity payment. Note: the status field as exposed by Google Patents reflects the most recent legal-status event we can extract; for litigation-grade verification consult the CNIPA portal directly.

## `patent_type` (type: `string`):

CNIPA recognises THREE distinct patent types: invention (highest bar, 20-year term, substantive examination), utility model (10-year term, only formal examination, lower bar but faster grant), and design (10-year term, covers shape / pattern / colour). Filter by type to focus your search. 'invention' filters to records with publication suffix A/B (e.g. CN101...A); 'utility' filters to U (CN20...U); 'design' filters to S (CN30...S); 'all' returns everything.

## `translate_titles` (type: `boolean`):

If true, when a patent has only a Chinese title (no machine-translated English title indexed by Google Patents), we'll fetch a best-effort English rendering via Google Translate's public web endpoint. Adds ~0.3s per untranslated record. Recommended for Anglophone IP teams, M\&A diligence and competitive intelligence dashboards. Disable for raw Chinese-only output (cheaper and faster, useful for downstream native-Chinese tooling).

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

Maximum number of CNIPA patent records to push to the dataset. Each result page returns up to 100 patents; we auto-paginate to satisfy your limit. Typical competitive-intel workflows pull 50-500 per refresh. For a full CN-portfolio inventory of a single applicant set to 1000+. Hard ceiling 5000.

## Actor input object example

```json
{
  "query": "lithium battery",
  "applicant": "",
  "inventor": "",
  "ipc_class": "",
  "date_range": "year",
  "status": "all",
  "patent_type": "all",
  "translate_titles": true,
  "maxResults": 50
}
```

# 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 = {
    "query": "lithium battery",
    "applicant": "",
    "inventor": "",
    "ipc_class": "",
    "date_range": "year",
    "status": "all",
    "patent_type": "all",
    "translate_titles": true,
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/cnipa-china-patent-search").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 = {
    "query": "lithium battery",
    "applicant": "",
    "inventor": "",
    "ipc_class": "",
    "date_range": "year",
    "status": "all",
    "patent_type": "all",
    "translate_titles": True,
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/cnipa-china-patent-search").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 '{
  "query": "lithium battery",
  "applicant": "",
  "inventor": "",
  "ipc_class": "",
  "date_range": "year",
  "status": "all",
  "patent_type": "all",
  "translate_titles": true,
  "maxResults": 50
}' |
apify call nexgendata/cnipa-china-patent-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CNIPA China Patent Search — IP & Innovation Tracker",
        "description": "Search CNIPA Chinese patents by keyword (EN/ZH), applicant, IPC, date, status. Returns invention/utility/design patents with bilingual title+abstract, applicants, inventors, IPC, dates, family size, citations. IP attorneys, R&D, China competitive intel. PatSnap alt.",
        "version": "0.0",
        "x-build-id": "AcFlYtXAEDdg6FzCe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~cnipa-china-patent-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-cnipa-china-patent-search",
                "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~cnipa-china-patent-search/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-cnipa-china-patent-search",
                "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~cnipa-china-patent-search/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-cnipa-china-patent-search",
                "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": {
                    "query": {
                        "title": "Keyword search (English or Chinese)",
                        "type": "string",
                        "description": "Free-text keyword search across patent title + abstract. Accepts English OR Chinese (mixed allowed). Examples: 'lithium battery', '锂电池', 'solid state drive', 'gene editing', '半导体'. Patents.google.com indexes CNIPA records in BOTH English machine-translated title/abstract and the original Chinese, so an English keyword still matches a Chinese patent. Leave blank to pull all patents in the date window narrowed by applicant / IPC / status.",
                        "default": ""
                    },
                    "applicant": {
                        "title": "Applicant / assignee filter (optional)",
                        "type": "string",
                        "description": "Restrict results to a specific Chinese applicant (company, university, institute). Accepts partial English or Chinese name (case-insensitive). Examples: 'Huawei', 'BYD', 'CATL', '宁德时代', 'Tsinghua University', '清华大学', 'CAS' (Chinese Academy of Sciences). Especially useful for monitoring a single Chinese competitor's filing cadence or running a Chinese deep-tech portfolio inventory for M&A diligence.",
                        "default": ""
                    },
                    "inventor": {
                        "title": "Inventor filter (optional)",
                        "type": "string",
                        "description": "Restrict results to patents naming a specific inventor. Accepts English or Chinese name. Examples: 'Robin Li', '李彦宏', 'Jack Ma'. Useful for following a known prolific researcher across employer changes (common in Chinese hardware / AI labs).",
                        "default": ""
                    },
                    "ipc_class": {
                        "title": "IPC class filter (optional)",
                        "type": "string",
                        "description": "International Patent Classification (IPC) symbol — the global standard used by CNIPA, USPTO, EPO and WIPO. Use the section letter (e.g. 'H' = Electricity), the 4-character class (e.g. 'H01M' = batteries, 'G06N' = AI/ML, 'C12N' = micro-organisms / genetic engineering), or a full subgroup (e.g. 'H01M10/0525' = lithium secondary cells). See cpc-tooltip below. Leave blank for any class.",
                        "default": ""
                    },
                    "date_range": {
                        "title": "Date range (filing-date window)",
                        "enum": [
                            "month",
                            "quarter",
                            "year",
                            "3year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter by filing date at CNIPA. 'month' = trailing 30 days; 'quarter' = trailing 90 days; 'year' = trailing 365 days; '3year' = trailing 3 years (most common for competitive intel — long enough to catch quarterly cadence, short enough to filter noise); 'all' = no date filter (search the full CNIPA index back to 1985).",
                        "default": "year"
                    },
                    "status": {
                        "title": "Patent status filter",
                        "enum": [
                            "all",
                            "pending",
                            "granted",
                            "expired",
                            "abandoned"
                        ],
                        "type": "string",
                        "description": "CNIPA patent lifecycle status. 'all' = no status filter (default). 'pending' = filed but not yet granted (the public application is published 18 months after filing). 'granted' = currently in force, fees paid. 'expired' = exclusive term ended (20 years for invention, 10 years for utility model and design from filing date). 'abandoned' = applicant let lapse before grant or before annuity payment. Note: the status field as exposed by Google Patents reflects the most recent legal-status event we can extract; for litigation-grade verification consult the CNIPA portal directly.",
                        "default": "all"
                    },
                    "patent_type": {
                        "title": "Patent type filter",
                        "enum": [
                            "all",
                            "invention",
                            "utility",
                            "design"
                        ],
                        "type": "string",
                        "description": "CNIPA recognises THREE distinct patent types: invention (highest bar, 20-year term, substantive examination), utility model (10-year term, only formal examination, lower bar but faster grant), and design (10-year term, covers shape / pattern / colour). Filter by type to focus your search. 'invention' filters to records with publication suffix A/B (e.g. CN101...A); 'utility' filters to U (CN20...U); 'design' filters to S (CN30...S); 'all' returns everything.",
                        "default": "all"
                    },
                    "translate_titles": {
                        "title": "Translate Chinese-only titles to English",
                        "type": "boolean",
                        "description": "If true, when a patent has only a Chinese title (no machine-translated English title indexed by Google Patents), we'll fetch a best-effort English rendering via Google Translate's public web endpoint. Adds ~0.3s per untranslated record. Recommended for Anglophone IP teams, M&A diligence and competitive intelligence dashboards. Disable for raw Chinese-only output (cheaper and faster, useful for downstream native-Chinese tooling).",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max patent records to return",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of CNIPA patent records to push to the dataset. Each result page returns up to 100 patents; we auto-paginate to satisfy your limit. Typical competitive-intel workflows pull 50-500 per refresh. For a full CN-portfolio inventory of a single applicant set to 1000+. Hard ceiling 5000.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
