China Company Check

Look up and verify mainland-China (PRC) companies from official government registration data — from any AI agent, in one line of config.

China-Check exposes a small, free, no-auth Model Context Protocol (MCP) server. This repository is an open Agent Skill + integration kit that lets Claude, Cursor, Windsurf, OpenClaw, Hermes-style function-calling models, and any MCP-capable agent search Chinese companies and pull a structured registration snapshot (legal name, legal representative, status, registered capital, Unified Social Credit Code, address, business scope, industry, and more) sourced from the official GSXT / SAMR registry.

• 🌐 Server: https://www.china-check.com/api/mcp/mcp
• 🔌 Transport: MCP Streamable HTTP (spec 2025-06-18)
• 🔑 Auth: none — connect and call
• 💵 Cost: the two lookup tools here are free
• 🈶 Translation: enum/label fields returned in en, ru, ar, ja, and more

This kit is read-only and query-only. It never writes data and never takes payment. Fuller paid due-diligence reports (risk, litigation, ownership/UBO, IP) live on the China-Check website and are entirely optional.

---

Table of contents

• Why
• What you get
• The two tools
• 60-second quickstart
• Install / connect per agent
  • Claude Code
  • Claude Desktop
  • Cursor / Windsurf / VS Code
  • OpenClaw
  • Hermes & other function-calling models
  • Any language (raw JSON-RPC)
  • As an Agent Skill
• Usage examples
• Data reference
• Language support
• Limits & good behavior
• FAQ
• Contributing
• License

---

Why

Verifying a Chinese supplier, factory, partner, or counterparty usually means wrestling with Chinese-only registry portals, CAPTCHAs, and inconsistent name matching. China-Check turns that into two clean tool calls your agent can make directly:

1. Find the right legal entity by name, brand, domain, phone, or credit code.
2. Fetch a translated, structured registration snapshot for it.

Because it speaks MCP over plain HTTP with no auth, wiring it into an agent takes one line.

What you get

china-check-skill/
├── README.md                     ← you are here
├── SKILL.md                      ← Anthropic Agent Skill (drop-in)
├── LICENSE                       ← MIT
├── docs/
│   ├── tools.md                  ← full tool reference + real sample I/O
│   ├── data-fields.md            ← every returned field, explained
│   └── integrations/             ← per-agent connection guides
│       ├── claude.md
│       ├── cursor-windsurf.md
│       ├── openclaw.md
│       ├── hermes.md
│       └── generic-mcp.md
├── schemas/
│   ├── search_chinese_company.json
│   ├── get_company_snapshot.json
│   └── openai-tools.json         ← both tools in OpenAI/function-calling format
├── config/
│   ├── claude_desktop_config.json
│   └── mcp.json                  ← generic Streamable-HTTP config
└── examples/
    ├── python/                   ← official MCP SDK + zero-dep bridge
    ├── node/                     ← official MCP SDK
    └── curl/                     ← raw JSON-RPC over HTTP

The two tools

Tool	What it does	Key inputs	Returns
search_chinese_company	Find PRC companies by name, brand, website domain, phone, or Unified Social Credit Code.	query (1–100 chars), language?	companies[] (each with companyId, names, registrationNo, legalPersonName, regCapital, companyType, base) + total
get_company_snapshot	Free official registration snapshot for one company.	companyId? or query?, language?	company_id, snapshot{…} (20+ fields), report_options, purchase_url, disclaimer

Typical flow: search → take a companyId → snapshot. You can also call get_company_snapshot with just a query and it resolves the best match for you.

Full schemas and verbatim sample responses: docs/tools.md.

---

60-second quickstart

Any MCP client that supports remote Streamable-HTTP servers — just point it at the URL:

{
  "mcpServers": {
    "china-check": {
      "type": "http",
      "url": "https://www.china-check.com/api/mcp/mcp"
    }
  }
}

Then ask your agent:

"Search China-Check for 华为 and give me the registration snapshot of Huawei Technologies."

No API key. No signup.

---

Install / connect per agent

Claude Code

claude mcp add --transport http china-check https://www.china-check.com/api/mcp/mcp

Verify:

claude mcp list

You should see china-check with tools search_chinese_company and get_company_snapshot. Full guide: docs/integrations/claude.md.

Claude Desktop

Claude Desktop connects to remote MCP servers through the mcp-remote bridge. Add this to claude_desktop_config.json (Settings → Developer → Edit Config) — or copy config/claude_desktop_config.json:

{
  "mcpServers": {
    "china-check": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://www.china-check.com/api/mcp/mcp"]
    }
  }
}

Restart Claude Desktop. Requires Node.js (for npx).

Cursor / Windsurf / VS Code

These support remote MCP servers natively. Add to your MCP config (.cursor/mcp.json, Windsurf MCP settings, or VS Code mcp.json) — see config/mcp.json:

{
  "mcpServers": {
    "china-check": {
      "type": "http",
      "url": "https://www.china-check.com/api/mcp/mcp"
    }
  }
}

Details & older-client fallbacks: docs/integrations/cursor-windsurf.md.

OpenClaw

OpenClaw and similar autonomous-agent runtimes consume MCP servers. Register China-Check as a Streamable-HTTP MCP server using the same URL and no credentials. Step-by-step (with the raw-bridge fallback for runtimes that don't yet ship an HTTP MCP client): docs/integrations/openclaw.md.

Hermes & other function-calling models

Hermes (Nous Research) and other tool-calling LLMs don't speak MCP natively — they emit tool calls that your harness executes. Give the model these two function definitions and route its calls to the MCP endpoint:

• OpenAI/tools[] format: schemas/openai-tools.json
• A ready Python bridge exposing search_chinese_company() / get_company_snapshot() as plain functions: examples/python/bridge.py

Full walkthrough (system-prompt snippet + dispatch loop): docs/integrations/hermes.md.

Any language (raw JSON-RPC)

The server is plain HTTP JSON-RPC. Minimal curl: examples/curl/raw-jsonrpc.sh. Reference client with no MCP SDK dependency (Python + httpx, handles JSON and SSE responses): examples/python/bridge.py.

As an Agent Skill

Drop SKILL.md (this whole folder) into your Skills directory (e.g. ~/.claude/skills/china-check/ or a project's .claude/skills/). The skill tells the agent when and how to use the two tools. Pair it with the MCP connection above so the tools are actually available.

---

Usage examples

Python — official MCP SDK

import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

URL = "https://www.china-check.com/api/mcp/mcp"

async def main():
    async with streamablehttp_client(URL) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()

            hits = await session.call_tool(
                "search_chinese_company", {"query": "华为", "language": "en"}
            )
            print(hits.content[0].text)   # JSON string: { "companies": [...], "total": ... }

            snap = await session.call_tool(
                "get_company_snapshot", {"query": "阿里巴巴", "language": "en"}
            )
            print(snap.content[0].text)   # JSON string: { "company_id", "snapshot": {...}, ... }

asyncio.run(main())

pip install "mcp>=1.0" — full script in examples/python/quickstart.py.

Node — official MCP SDK

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const client = new Client({ name: "china-check-example", version: "1.0.0" });
await client.connect(
  new StreamableHTTPClientTransport(new URL("https://www.china-check.com/api/mcp/mcp"))
);

const hits = await client.callTool({
  name: "search_chinese_company",
  arguments: { query: "华为", language: "en" },
});
console.log(hits.content[0].text);

npm i @modelcontextprotocol/sdk — full script in examples/node/quickstart.mjs.

curl — raw JSON-RPC

See examples/curl/raw-jsonrpc.sh for the full initialize → initialized → tools/call sequence (Streamable HTTP carries a session id in the Mcp-Session-Id response header).

---

Data reference

search_chinese_company → each item in companies[]:

Field	Meaning
companyId	Stable id — pass to get_company_snapshot.
nameZh	Registered Chinese name.
nameTranslated	Translated name (may equal nameZh when no translation applies).
registrationNo	Registration / Unified Social Credit Code.
establishedAt	Establishment date (YYYY-MM-DD).
legalPersonName	Legal representative.
regCapital	Registered capital (e.g. CNY 41,141,131,820).
companyType	Entity type (translated).
base	Province / region.

get_company_snapshot → snapshot{}: companyName, legalRepresentative, registrationStatus, establishedDate, registeredCapital, paidInCapital, creditCode, registrationNumber, organizationCode, taxNumber, companyType, industry, province, registeredAddress, businessScope, staffSize, approvedDate, registrationAuthority, businessTerm, formerNames[]. Plus top-level report_options, purchase_url, disclaimer.

Every field explained with examples: docs/data-fields.md.

Language support

Pass language (ISO code) to translate enum/label fields and set the deep-link locale. Known-good: en (default), ru, ar, ja, ko, es, pt, vi, id, th. Chinese proper nouns (company/person names, addresses, business scope) are returned as registered; enum-like fields (status, type, province) are translated.

Limits & good behavior

• Mainland China only. Hong Kong / Macau / Taiwan entities and individuals are excluded.
• Query length: query ≤ 100 chars; companyId ≤ 64 chars.
• total in search results reflects the registry match count and can be large (capped); iterate on the returned companies[].
• Be a good citizen: cache results you reuse, prefer a specific companyId over repeated fuzzy query snapshots, and don't hammer the endpoint in tight loops.
• Read-only: these tools never modify data or charge money.

FAQ

Do I need an account or key? No. The two lookup tools are open and free.

Is this official government data? It reflects official Chinese registration data (GSXT / SAMR). Treat it as informational; verify anything mission-critical against the source.

What about risk, lawsuits, ownership, or IP? Those are part of China-Check's fuller paid reports on the website — outside this free MCP surface. When present, report_options / purchase_url point to them; both may be empty when the paid catalog isn't exposed.

My client only supports stdio MCP servers. Use the mcp-remote bridge (see Claude Desktop above) — it proxies the remote server over stdio.

Can I use this without any MCP SDK? Yes — examples/python/bridge.py talks raw JSON-RPC over HTTP with only httpx.

Contributing

Issues and PRs welcome — especially additional integration recipes (new agent runtimes), language checks, and example clients in more languages. Please keep the kit read-only and dependency-light.

License

MIT. China-Check is a service of china-check.com; this integration kit is community-friendly and provided as-is. "China-Check" names the service for interoperability only.