DEV Community: GoldBean

2026 Chinese LLM API Benchmark: 7 Models Ranked by Real Data (July Update)

GoldBean — Fri, 31 Jul 2026 08:44:03 +0000

2026 Chinese LLM API Benchmark: 7 Models Tested with Real Data

DeepSeek-v4-pro leads with 81.1 overall score. Kimi K2.6 Thinking dominates hallucination control at 90.0. Doubao Seed2.0-pro tops code generation at 85.7. But no single model covers all scenarios.

Why Benchmark Now?

The Chinese LLM market has shifted from "hundred flowers blooming" to "scenario differentiation". By early 2026, hundreds of models completed regulatory filing, but only 7-8 providers offer truly production-grade API services.

The real pain: Same algorithm problem, 8 models give 8 different answers. Some respond in 0.5s, others timeout at 60s. Cost per million tokens ranges from ¥15 to ¥150.

This benchmark is based on Bonree Data's May 2026 report covering 1900+ real-world API calls.

Overall Scores (Bonree Data 2026.05)

Model	Overall	Code	Math	Planning	Hallucination	Price (¥/M tokens)
DeepSeek-v4-pro	81.1	85	82	80	78	15
Kimi K2.6 Thinking	78.5	80	75	72	90.0	60
Doubao Seed2.0-pro	76.2	85.7	70	75	74	50
Qwen3.5	74.8	78	76	73	72	20
Hunyuan-large	72.5	75	70	71	73	30
ERNIE 4.5	70.1	72	68	70	71	40
GLM-4	68.9	70	65	69	70	25

Overall score = average of 4 core scenarios, max 100

Key Findings

Finding 1: No Universal Champion

Every model has clear strengths and weaknesses. DeepSeek is balanced but not best-in-class; Kimi dominates hallucination control but scores only 72 in task planning; Doubao leads code generation but drops to 70 in math reasoning.

Finding 2: Token Efficiency Varies 3-5x

Same prompt, different models consume 3-5x different token counts. Total cost = unit price × token volume. DeepSeek's efficiency means its real cost is often lower than cheaper alternatives.

Finding 3: Response Speed Tiers

Tier 1 (< 0.5s TTFT): DeepSeek, Doubao
Tier 2 (0.5-2s): Qwen, GLM
Tier 3 (> 3s or timeout): Some edge cases

For real-time chat, >2s is a hard UX red line.

Model Profiles

DeepSeek-v4-pro (81.1 overall, Best Value)

Architecture: ~1T params MoE, ~370B active
Context: 256K
Strengths: Code (85), Math (82), Long text
Weaknesses: Hallucination control (78) behind Kimi
Price: ¥15/M tokens — open source MIT
Best for: Budget-sensitive projects needing full-scenario coverage

Kimi K2.6 Thinking (90.0 hallucination control)

Context: 256K
Strengths: Hallucination control (90), Long documents, Fact checking
Weaknesses: Task planning (72), Slower response
Price: ¥60/M tokens
Best for: Finance, medical, legal — scenarios demanding high factual accuracy

Doubao Seed2.0-pro (85.7 code generation)

Context: 262K
Strengths: Code completion, Code review, Bug fixing
Weaknesses: Math reasoning (70), General chat
Price: ¥50/M tokens
Best for: IDE plugins, Code review tools, Technical Q&A

Unified Gateway: Why Not Just Pick One?

Managing 7 API keys, 7 SDKs, and 7 billing dashboards is painful. A unified gateway lets you:

// Call DeepSeek
fetch('https://goldbean-api.xyz/ai/ds/chat', {
  headers: { 'Authorization': 'Bearer KEY' },
  body: JSON.stringify({
    model: 'deepseek-v4-pro',
    messages: [{ role: 'user', content: 'Hello' }]
  })
});

// Switch to Kimi — only change path and model
fetch('https://goldbean-api.xyz/ai/kimi/chat', {
  ...sameConfig,
  model: 'kimi-k2.6'
});

GoldBean provides:

One API key for 7 providers
OpenAI-compatible endpoints
25-40% cheaper than official direct pricing
Built-in playground for side-by-side comparison
Free tier: 20 calls/day

Try the Playground

Compare models live without writing code:
https://goldbean-api.xyz/playground

Data Source

Bonree Data, China Mainstream Large Model API Service Performance and Comprehensive Evaluation Report, May 2026. 1900+ real environment calls across code generation, math reasoning, task planning, and hallucination control.

What's your experience with Chinese LLM APIs? Any model surprised you?

2026 Chinese LLM API Benchmark: 7 Models Tested with Real Data

GoldBean — Fri, 31 Jul 2026 08:38:44 +0000

2026 Chinese LLM API Benchmark: 7 Models Tested with Real Data

DeepSeek-v4-pro leads with 81.1 overall score. Kimi K2.6 Thinking dominates hallucination control at 90.0. Doubao Seed2.0-pro tops code generation at 85.7. But no single model covers all scenarios.

Why Benchmark Now?

The real pain: Same algorithm problem, 8 models give 8 different answers. Some respond in 0.5s, others timeout at 60s. Cost per million tokens ranges from ¥15 to ¥150.

This benchmark is based on Bonree Data's May 2026 report covering 1900+ real-world API calls.

Overall Scores (Bonree Data 2026.05)

Model	Overall	Code	Math	Planning	Hallucination	Price (¥/M tokens)
DeepSeek-v4-pro	81.1	85	82	80	78	15
Kimi K2.6 Thinking	78.5	80	75	72	90.0	60
Doubao Seed2.0-pro	76.2	85.7	70	75	74	50
Qwen3.5	74.8	78	76	73	72	20
Hunyuan-large	72.5	75	70	71	73	30
ERNIE 4.5	70.1	72	68	70	71	40
GLM-4	68.9	70	65	69	70	25

Overall score = average of 4 core scenarios, max 100

Key Findings

Finding 1: No Universal Champion

Finding 2: Token Efficiency Varies 3-5x

Same prompt, different models consume 3-5x different token counts. Total cost = unit price × token volume. DeepSeek's efficiency means its real cost is often lower than cheaper alternatives.

Finding 3: Response Speed Tiers

Tier 1 (< 0.5s TTFT): DeepSeek, Doubao
Tier 2 (0.5-2s): Qwen, GLM
Tier 3 (> 3s or timeout): Some edge cases

For real-time chat, >2s is a hard UX red line.

Model Profiles

DeepSeek-v4-pro (81.1 overall, Best Value)

Architecture: ~1T params MoE, ~370B active
Context: 256K
Strengths: Code (85), Math (82), Long text
Weaknesses: Hallucination control (78) behind Kimi
Price: ¥15/M tokens — open source MIT
Best for: Budget-sensitive projects needing full-scenario coverage

Kimi K2.6 Thinking (90.0 hallucination control)

Context: 256K
Strengths: Hallucination control (90), Long documents, Fact checking
Weaknesses: Task planning (72), Slower response
Price: ¥60/M tokens
Best for: Finance, medical, legal — scenarios demanding high factual accuracy

Doubao Seed2.0-pro (85.7 code generation)

Context: 262K
Strengths: Code completion, Code review, Bug fixing
Weaknesses: Math reasoning (70), General chat
Price: ¥50/M tokens
Best for: IDE plugins, Code review tools, Technical Q&A

Unified Gateway: Why Not Just Pick One?

Managing 7 API keys, 7 SDKs, and 7 billing dashboards is painful. A unified gateway lets you:

// Call DeepSeek
fetch('https://goldbean-api.xyz/ai/ds/chat', {
  headers: { 'Authorization': 'Bearer KEY' },
  body: JSON.stringify({
    model: 'deepseek-v4-pro',
    messages: [{ role: 'user', content: 'Hello' }]
  })
});

// Switch to Kimi — only change path and model
fetch('https://goldbean-api.xyz/ai/kimi/chat', {
  ...sameConfig,
  model: 'kimi-k2.6'
});

GoldBean provides:

One API key for 7 providers
OpenAI-compatible endpoints
25-40% cheaper than official direct pricing
Built-in playground for side-by-side comparison
Free tier: 20 calls/day

Try the Playground

Compare models live without writing code:
https://goldbean-api.xyz/playground

Data Source

What's your experience with Chinese LLM APIs? Any model surprised you?

GoldBean API: Use Baidu AI Without a Chinese Phone Number

GoldBean — Mon, 27 Jul 2026 06:52:35 +0000

53 endpoints. One API key. Zero onboarding pain. Pay per call from $0.005.

The Problem: Baidu Cloud Is Powerful, But Inaccessible

Baidu has some of the most mature AI services for Chinese-language tasks. Their OCR engine handles mixed Chinese-English documents better than most Western alternatives. Their NLP stack covers everything from text correction to keyword extraction. And the Qianfan LLM platform offers competitive models at aggressive pricing.

But here is the catch: signing up for Baidu Cloud as a non-Chinese developer is painful.

You need a Mainland China phone number for SMS verification
You must complete real-name authentication with a Chinese national ID
Payment requires Alipay, WeChat Pay, or a Chinese bank card
Documentation is primarily in Chinese
Support channels expect a domestic user context

For overseas developers, startups, and SaaS builders, this is a hard wall. You either abandon the tool or spend weeks routing through proxies, translation layers, and third-party resellers.

That is exactly why we built GoldBean API.

What Is GoldBean API?

GoldBean is a unified gateway to Baidu's AI ecosystem. We handle the account management, authentication, and billing with Baidu on our side. You get a single API key and immediate access to 53 production-ready endpoints.

What you get:

Category	Endpoints	Examples
OCR	10	General text, handwriting, web image, QR code, business license
Translation	3	Text, doc-level, domain-specific (medical/legal)
TTS & ASR	5	Mandarin TTS, speech recognition, speaker diarization
NLP	12	Sentiment analysis, NER, keyword extraction, text correction, similarity
LLM (Qianfan)	7	OpenAI-compatible chat, embeddings, reranker, image gen, DeepThink
Search & Knowledge	5	Web search, news, image search
Image Recognition	6	Object detection, plant/animal/dish/car identification, logo

Authentication is dead simple:

X-API-Key: gb_live_xxxxxxxx

No OAuth dance. No token refresh. No regional account setup.

Quick Start: OCR in 30 Seconds

cURL

curl -X POST https://api.goldbean-api.xyz/v1/ocr \
  -H "X-API-Key: gb_live_xxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "image": "https://example.com/invoice-screenshot.jpg",
    "type": "general",
    "language": "CHN_ENG"
  }'

Python (requests)

import requests

API_KEY = "gb_live_xxxxxxxx"
BASE_URL = "https://api.goldbean-api.xyz/v1"

# 1. OCR on a remote image
resp = requests.post(
    f"{BASE_URL}/ocr",
    headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
    json={
        "image": "https://example.com/invoice-screenshot.jpg",
        "type": "general",
        "language": "CHN_ENG"
    }
)
data = resp.json()
print(data["text"])          # Extracted text
print(data["confidence"])    # 0.97

Response:

{
  "text": "Invoice #: INV-2024-001\nDate: 2024-07-25\nTotal: ¥1,250.00",
  "confidence": 0.972,
  "words": [
    {"word": "Invoice", "location": {"top": 12, "left": 34, "width": 89, "height": 21}},
    ...
  ]
}

Quick Start: Translation

cURL

curl -X POST https://api.goldbean-api.xyz/v1/translate \
  -H "X-API-Key: gb_live_xxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Machine learning models require large datasets for training.",
    "source": "en",
    "target": "zh"
  }'

Python (requests)

import requests

API_KEY = "gb_live_xxxxxxxx"
BASE_URL = "https://api.goldbean-api.xyz/v1"

resp = requests.post(
    f"{BASE_URL}/translate",
    headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
    json={
        "text": "Machine learning models require large datasets for training.",
        "source": "en",
        "target": "zh"
    }
)
print(resp.json()["translation"])  # "机器学习模型需要大量数据集进行训练。"

Pricing: Transparent and Predictable

We charge per API call. No monthly minimums. No prepaid wallet lock-in.

Tier	Price per Call	Example Endpoints
Basic	$0.005	General OCR, text translation, sentiment analysis
Standard	$0.005	Handwriting OCR, doc-level translation, TTS
Premium	$0.005–$0.08	LLM chat (per 1K tokens), image generation, DeepThink

Subscription plans (optional, for high-volume users):

Plan	Monthly Cost	Includes
Starter	$5	100 calls + priority support
Monthly	$9.90	1,000 calls + premium endpoints access
Quarterly	$25	3,000 calls + LLM quota
Yearly	$89	15,000 calls + full LLM access

Free tier: 50 calls/day/IP for testing. No credit card required.

How does this compare to Baidu Cloud direct?

Factor	Baidu Cloud Direct	GoldBean API
Signup	Chinese phone + real-name ID	Email only
Payment	Alipay / WeChat / Chinese bank	PayPal, card, Alipay, USDC (x402)
Pricing	Prepaid wallet, complex tiers	Per-call, no minimum
Docs	Chinese-first	English-first
Support	Domestic-focused	English email/Discord
LLM access	Separate Qianfan signup	Built-in, OpenAI-compatible

For low-to-mid volume usage, our pricing is competitive. For high volume, Baidu direct can be cheaper — if you can get an account. GoldBean is the bridge for everyone else.

LLM Access: OpenAI-Compatible Qianfan Models

GoldBean exposes Baidu's Qianfan LLM platform through an OpenAI-compatible interface. Change your base_url and keep your existing client code.

from openai import OpenAI

client = OpenAI(
    api_key="gb_live_xxxxxxxx",
    base_url="https://api.goldbean-api.xyz/v1"
)

response = client.chat.completions.create(
    model="baidu-deepseek-ocr",
    messages=[{"role": "user", "content": "Summarize this invoice text: ..."}]
)
print(response.choices[0].message.content)

Available models include general chat, vision-language, embeddings, reranker, and reasoning (DeepThink) variants.

Who Is This For?

Cross-border e-commerce sellers

OCR Chinese product labels, invoices, and customs documents
Translate listings between Chinese and English/Spanish/Arabic
Extract keywords from competitor listings for SEO

Document processing pipelines

Batch-process scanned Chinese contracts and forms
Convert mixed-language PDFs to structured text
Build RAG systems over Chinese knowledge bases

Chinese NLP research & products

Sentiment analysis on Weibo/Xiaohongshu content
Named entity recognition for Chinese financial news
Text similarity for deduplication and matching

AI application builders

Add Chinese-language capabilities without managing Baidu accounts
Integrate TTS for Mandarin voice assistants
Use Qianfan LLMs as a cost-effective alternative for Chinese contexts

Conclusion

Baidu's AI stack is too good to be locked behind a domestic-only signup flow. GoldBean API removes that barrier.

If you are building something that needs Chinese-language OCR, translation, NLP, or LLM inference, you can be up and running in under five minutes.

Get started:

Grab a free API key at goldbean-api.xyz
Run the OCR or translation example above
Upgrade to a paid plan when you are ready

Questions or feedback?

GitHub: github.com/wuzenghai616-lang/goldbean
Discord: GoldBean community server
Email: wuzenghai616@gmail.com

GoldBean API is an independent gateway and is not affiliated with Baidu. Baidu is a trademark of Baidu, Inc.

Build a Chinese AI MCP Server with x402 Micropayments: My Journey Creating GoldBean

GoldBean — Tue, 21 Jul 2026 04:53:49 +0000

The Problem

Building apps that need Chinese AI capabilities — OCR, translation, text-to-speech, image recognition — typically means:

Sign up for Baidu AI Cloud (requires Chinese phone + identity verification)
Get API keys and manage credential rotation
Pre-pay credits in CNY via Alipay/WeChat
Write adapter code to normalize 53 different API formats
Monitor billing across multiple Baidu service accounts

For international developers, step 1 is already a wall. For AI agent builders using MCP (Model Context Protocol), steps 2-4 are friction that kills experimentation.

The Solution: GoldBean MCP Server

GoldBean is an MCP server that wraps 53 Baidu AI endpoints behind a single protocol, with x402 micropayment replacing API keys entirely.

What that means in practice:

npx goldbean-mcp

That one command gives you 53 tools in any MCP-compatible client (Cursor, Claude Desktop, Cline, Codex):

Category	Tools	Price per call
OCR (19 types)	General, Handwriting, Table, ID Card, Business License, License Plate, Train Ticket, Formula, Webpage, Acrobat...	$0.01-0.03
Image Recognition (10)	Plant, Animal, Car Model, Dish, Landmark, Logo, Currency...	$0.02-0.05
ERNIE LLM	Text generation, chat completion	$0.05-0.08
Translation	28+ language pairs	$0.005
TTS / ASR	Text to speech, speech to text	$0.02
NLP (6 types)	Sentiment, keyword extraction, emotion, comment analysis...	$0.01
Web Search	Instant answers + related topics	$0.005
Vision / Detection	Face, gesture, body pose, image generation	$0.03-0.05

No API keys. No signup. Pay per call with USDC on Base.

Free tier: 50 calls/day per IP — no wallet needed.

How x402 Works (Under the Hood)

x402 is the HTTP 402 Payment Required protocol, built by Coinbase on Base (Ethereum L2). Here's the flow:

Client calls https://goldbean-api.xyz/api/ocr/general (no API key header)
Server responds with HTTP 402 + payment details (amount, wallet address, facilitator URL)
Client pays $0.01 USDC to the server wallet via x402 facilitator (2-second settlement on Base)
Client retries with the payment receipt in the X-Payment header
Server validates payment, processes the request, returns result

The entire payment cycle is ~2 seconds. For MCP clients, the x402 SDK handles this automatically.

Architecture

+-----------------+     +------------------+     +-------------+
|  MCP Client     |---->|  goldbean-mcp    |---->|  Baidu AI   |
| (Cursor/Cline)  |     |  (Node.js)       |     |  Cloud API  |
+-----------------+     +------------------+     +-------------+
                              |
                              | x402 payment
                              v
                        +-----------+
                        |  Base L2  |
                        |  (USDC)   |
                        +-----------+

The MCP server acts as both a protocol adapter (MCP to Baidu REST) and an x402 payment proxy. Each tool call triggers the payment flow, which is invisible to the end user if they have USDC in their wallet.

Getting Started

1. Install as MCP Server

Add to your MCP client config:

{
  "mcpServers": {
    "goldbean": {
      "command": "npx",
      "args": ["goldbean-mcp"]
    }
  }
}

2. For Free Tier (No Wallet Needed)

Just call any endpoint — 50 free calls per day per IP, no configuration required.

3. For Paid Tier (USDC on Base)

Set up an x402-compatible wallet with USDC on Base mainnet. The x402 SDK auto-detects and handles payment.

4. For Prepaid Credits (PayPal / Alipay)

Visit https://goldbean-api.xyz to purchase credits — no crypto needed.

Real-World Use Cases

OCR Pipeline for Chinese Documents

# Process a Chinese business license
result = mcp_client.call_tool("baidu_ocr_business_license", {
    "image": "https://example.com/license.jpg"
})
# Returns: company name, registered capital, legal representative, scope...

Multi-Language Translation Agent

# Translate Chinese content to 28+ languages in one MCP session
for lang in ["en", "ja", "ko", "fr", "de"]:
    result = mcp_client.call_tool("baidu_translation", {
        "text": "人工智能改变世界",
        "from": "zh",
        "to": lang
    })

ERNIE LLM Integration

# Use Baidu's ERNIE Bot as an MCP tool
result = mcp_client.call_tool("baidu_ernie_text", {
    "prompt": "Write a product description for a smart home device",
    "temperature": 0.7
})

Pricing

Plan	Price	Calls
Free	$0	50/day per IP
Starter	$5 one-time	100 calls
Monthly	$29.9/mo	Unlimited
Quarterly	$69/qtr	Unlimited
Yearly	$269/yr	Unlimited

Per-call: $0.01-$0.08 | Payment: x402 USDC (Base), PayPal, Alipay

Why MCP + x402 Matters

The MCP protocol is becoming the standard for AI agent tool access. But every MCP server still needs authentication — API keys, OAuth tokens, or subscription management.

x402 eliminates all of that. Payment replaces authentication. One USDC transaction per call. No key management. No credential rotation. No "your API key has expired" errors.

This is the future of AI agent economics: pay-per-call, no friction, protocol-native.

Baidu OCR API: 19 Recognition Scenarios From Handwriting to Medical Receipts

GoldBean — Tue, 14 Jul 2026 06:12:32 +0000

If you've ever needed to extract text from a handwritten note, parse a medical prescription, or digitize a complex table from a scanned document, you know how frustrating OCR can be. Most APIs handle basic printed text well, but fall apart the moment the input gets messy.

Baidu's OCR API supports 19 different recognition scenarios, covering everything from standard text extraction to specialized tasks like handwriting recognition, mathematical formula parsing, and medical receipt processing. And with GoldBean, you can access all of them through a single unified API endpoint — no Baidu Cloud account required.

In this tutorial, I'll walk you through each scenario with real code examples.

What You'll Need

A GoldBean API key (free tier: 50 calls/day, no signup needed)
Node.js 18+ or Python 3.8+
An image file to test with

The 19 OCR Scenarios at a Glance

Category	Endpoints	Use Case
General Text	4	Basic, high-precision, low-light, web image
Handwriting	1	Hand-drawn notes and signatures
Form/Table	2	Structured forms and tables
ID Documents	4	ID cards, passports, business licenses, bank cards
Math & Formula	1	Mathematical expressions and equations
Medical	2	Medical prescriptions and hospital receipts
Vehicle	2	License plates and vehicle certificates
Specialized	3	QR codes, numbers, lottery tickets

Quick Start: 5-Minute Integration

Node.js

import axios from 'axios';

const GOLDBEAN_API = 'https://goldbean-api.xyz/v1/ocr';
const API_KEY = 'your-goldbean-api-key';

async function recognizeImage(imagePath, ocrType) {
  const fs = await import('fs');
  const imageBuffer = fs.readFileSync(imagePath);
  const base64Image = imageBuffer.toString('base64');

  const response = await axios.post(GOLDBEAN_API, {
    image: base64Image,
    type: ocrType  // e.g., 'handwriting', 'formula', 'medical_receipt'
  }, {
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json'
    }
  });

  return response.data;
}

// Example: Recognize handwritten text
const result = await recognizeImage('./handwritten-note.jpg', 'handwriting');
console.log(result.text);

Python

import base64
import requests

GOLDBEAN_API = 'https://goldbean-api.xyz/v1/ocr'
API_KEY = 'your-goldbean-api-key'

def recognize_image(image_path, ocr_type):
    with open(image_path, 'rb') as f:
        image_data = base64.b64encode(f.read()).decode('utf-8')

    response = requests.post(
        GOLDBEAN_API,
        json={
            'image': image_data,
            'type': ocr_type
        },
        headers={
            'Authorization': f'Bearer {API_KEY}',
            'Content-Type': 'application/json'
        }
    )
    return response.json()

# Example: Parse a medical prescription
result = recognize_image('./prescription.jpg', 'medical_prescription')
print(result['data']['medicines'])

Deep Dive: 5 Most Useful Scenarios

1. Handwriting Recognition

Perfect for digitizing meeting notes, whiteboard photos, or old documents.

// Recognize handwritten English or Chinese text
const result = await recognizeImage('./notes.jpg', 'handwriting');

// Response includes:
// {
//   "text": "Meeting notes: launch v2 by Friday",
//   "words": [
//     { "text": "Meeting", "location": {"left": 10, "top": 5, ...} },
//     { "text": "notes:", "location": {...} }
//   ],
//   "probability": 0.97
// }

Key advantage: Works with both English and Chinese handwriting, including mixed-language documents.

2. Mathematical Formula Recognition

Upload a photo of an equation and get LaTeX back. This is a game-changer for education tech.

result = recognize_image('./equation.png', 'formula')
# Returns: { "formula": "E = mc^2", "latex": "E = mc^2" }

Supports fractions, integrals, summations, matrices, and multi-line equations.

3. Table Extraction

Extract structured data from tables in scanned documents or screenshots.

const result = await recognizeImage('./table-screenshot.png', 'table');

// Returns structured table data:
// {
//   "tables": [
//     {
//       "header": ["Product", "Price", "Stock"],
//       "rows": [
//         ["Widget A", "$9.99", "142"],
//         ["Widget B", "$14.99", "87"]
//       ]
//     }
//   ]
// }

4. Medical Receipt Processing

Digitize hospital bills and insurance claims automatically.

result = recognize_image('./hospital-bill.jpg', 'medical_receipt')
# Returns structured data including:
# - Patient name
# - Total amount
# - Itemized charges
# - Hospital name and date

This is especially useful for insurance automation and medical expense tracking apps.

5. ID Card Recognition

Extract information from ID cards, passports, and business licenses.

const result = await recognizeImage('./id-card.jpg', 'id_card');
// Returns:
// {
//   "name": "ZHANG SAN",
//   "id_number": "110101199001011234",
//   "address": "No.123 Main Street, Beijing",
//   "birthday": "1990-01-01",
//   "gender": "Male"
// }

Using with MCP (Model Context Protocol)

If you're using Cursor, Claude Desktop, or any MCP-compatible AI tool, you can call the OCR endpoints directly through the GoldBean MCP Server:

{
  "mcpServers": {
    "goldbean": {
      "command": "npx",
      "args": ["-y", "goldbean-mcp"],
      "env": {
        "GOLDBEAN_API_KEY": "your-api-key"
      }
    }
  }
}

Once configured, just ask your AI assistant: "Read the text in this image" and it will automatically pick the right OCR scenario.

Pricing

Each OCR call costs just $0.001 through GoldBean — that's 10x cheaper than most Western OCR APIs. With the subscription plans, it gets even cheaper:

Plan	Price	Calls/month	Cost per call
Free	$0	50/day	$0
Starter	$5/mo	5,000	$0.001
Monthly	$9.9/mo	15,000	$0.0007
Yearly	$89/yr	200,000	$0.0005

Error Handling Best Practices

async function safeOCR(imagePath, ocrType) {
  try {
    const result = await recognizeImage(imagePath, ocrType);

    if (result.error_code) {
      switch (result.error_code) {
        case 'IMAGE_TOO_LARGE':
          // Compress and retry
          break;
        case 'NO_TEXT_FOUND':
          console.log('No text detected in image');
          break;
        case 'RATE_LIMIT_EXCEEDED':
          // Implement backoff
          break;
      }
    }

    return result;
  } catch (error) {
    if (error.response?.status === 402) {
      // Insufficient credits - handle payment
      console.error('Top up your credits at https://goldbean-api.xyz/buy-credits');
    }
    throw error;
  }
}

Tips for Best Results

Image quality matters. Minimum 300 DPI for printed text, 150 DPI for handwriting.
Crop unnecessary borders. Focus on the text region for higher accuracy.
Use the right scenario. Don't use general OCR for medical receipts — the specialized endpoint understands medical terminology.
Handle rotation. If your image is rotated, the API can auto-detect up to 30-degree rotation, but extreme angles need pre-processing.
Batch processing. For large volumes, use async processing to avoid timeouts.

Conclusion

Baidu's OCR API handles 19 different recognition scenarios that cover nearly every real-world use case — from casual handwriting to specialized medical and financial documents. Through GoldBean, you get a unified API that's 10x cheaper than alternatives like Google Cloud Vision or AWS Textract, with no Chinese phone number or Baidu Cloud account required.

The free tier gives you 50 calls per day with no signup, so you can start experimenting immediately.

Try GoldBean free: https://goldbean-api.xyz — 5 free calls/day, no signup needed

67 Baidu AI Endpoints Behind a Single REST API â No Chinese Phone Needed

GoldBean — Sun, 12 Jul 2026 07:13:18 +0000

If you've ever tried to use Baidu's AI APIs from outside China, you probably hit the same wall I did: you need a Chinese phone number to register. That's a non-starter for most developers.

So I built GoldBean â€” a single REST API that wraps 67 Baidu AI endpoints behind one URL. No Baidu account, no Chinese phone, no API key from Baidu. Just sign up, get credits, and call.

What's Inside

67 endpoints across 10 categories:

Category	Count	Examples
LLM Chat	3	ERNIE 4.0, DeepSeek Reasoning, DeepThink
OCR	19	General, Handwriting, QR Code, Bank Card, License, Stamp
Vision	10	Object, Plant, Animal, Dish, Currency, Car, Wine Recognition
NLP	9	Sentiment Analysis, Text Summary, Keyword Extraction
Image	4	AI Image Generation, Style Transfer
Voice	2	TTS (Text-to-Speech), ASR (Speech-to-Text)
Translation	1	Multi-language Translation
Video	2	Video Generation, Digital Human
Bio	1	HelixFold Protein Structure Prediction
Face/Body	4	Face Detection, Body Keypoints

Quick Start

1. Free Tier â€” No Signup Required

curl https://api.goldbean.io/free/ocr/general \
  -H "Content-Type: application/json" \
  -d '{"image":"https://example.com/receipt.jpg"}'

5 free calls per day per IP. No account, no API key, no credit card.

2. Paid Tier â€” Pay Per Call

curl https://api.goldbean.io/paid/llm-chat \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"Hello"}]}'

Pricing starts at $0.002/1K tokens for LLM chat, $0.01/call for OCR.

3. MCP Server â€” For AI Agents

{
  "mcpServers": {
    "goldbean": {
      "command": "npx",
      "args": ["-y", "goldbean-mcp@latest"],
      "env": {
        "GOLDBEAN_API_KEY": "your-api-key-here"
      }
    }
  }
}

Works with Cursor, Claude Desktop, Cline, Codex, and Continue.

npx goldbean-mcp

Payment Options

Method	Minimum	Use Case
PayPal	$1	Credit/debit card, global
Alipay	Â¥1	WeChat Pay, bank card (China)
USDC on Base	$0.01	x402 protocol, per-call crypto micropayment
Free tier	$0	5 calls/day per IP, no signup

Membership Plans (v9.7.0)

Plan	Price	Premium Quota
Monthly	$20/mo	Resets monthly
Quarterly	$60/qtr	Resets monthly
Yearly	$200/yr	Resets monthly

Basic + Standard endpoints are unlimited on all plans. Only 8 Premium endpoints (high-cost models like video gen, protein folding) have monthly USD quotas.

Real-World Examples

OCR: Extract Text from a Receipt

import requests

resp = requests.post(
    "https://api.goldbean.io/paid/ocr/receipt",
    headers={"Authorization": "Bearer YOUR_KEY"},
    json={"image": "https://example.com/receipt.jpg"}
)
print(resp.json()["words_result"])

LLM Chat: ERNIE 4.0

const resp = await fetch("https://api.goldbean.io/paid/llm-chat", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    messages: [{ role: "user", content: "Explain x402 protocol" }]
  })
});
const data = await resp.json();
console.log(data.choices[0].message.content);

TTS: Text-to-Speech

curl https://api.goldbean.io/paid/tts \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"Hello world","voice":"en-US"}' \
  --output audio.mp3

Why Not Just Use Baidu Directly?

No Chinese phone required â€” GoldBean handles Baidu registration
Single API key â€” One key for all 67 endpoints, not 10+ separate API keys
Global payments â€” PayPal and USDC, not just Chinese payment methods
MCP compatible â€” Plug into any AI agent that supports MCP
Unified billing â€” Pay-as-you-go or membership, all in one dashboard

I Wrapped 67 Baidu AI Endpoints Into a Single REST API With Pay-Per-Call Pricing

GoldBean — Sun, 12 Jul 2026 03:22:12 +0000

Monetizing AI APIs: A Guide to Pay-Per-Call Pricing with x402 Protocol

GoldBean — Sat, 11 Jul 2026 04:49:37 +0000

How to Build an MCP Server with x402 Micropayments: A Complete Tutorial

GoldBean — Sat, 11 Jul 2026 04:30:35 +0000

Monetize Any AI API with x402 Micropayments and MCP Protocol

GoldBean — Fri, 10 Jul 2026 04:42:08 +0000

The Opportunity

Baidu AI offers powerful capabilities — OCR, text-to-speech, LLM chat, image recognition — but monetizing them for a global audience is hard. Chinese AI APIs require a Chinese phone number for registration. International payment gateways don't work natively with AI agent workflows.

What if you could expose Baidu AI to the entire world, charge per call, and let AI agents pay automatically?

That's exactly what GoldBean does. In this tutorial, I'll show you the architecture and code patterns to monetize any AI API with x402 micropayments and MCP protocol.

Prerequisites

Node.js 20+
Basic understanding of HTTP APIs
A Baidu AI account (or any AI API you want to monetize)
Optional: a crypto wallet with USDC on Base

Architecture: x402 + MCP + Baidu AI

AI Agent (Claude/Cursor) → MCP Protocol (SSE) → GoldBean Server → Baidu AI API
                                    ↓
                            x402 Payment Layer
                            (USDC on Base L2)

The three layers work together:

MCP Layer: AI agents discover and call tools via Model Context Protocol
x402 Layer: Each paid call triggers an HTTP 402 payment flow — agent pays USDC, server verifies on-chain
AI Backend: Baidu AI processes the request and returns results

Step 1: Setting Up the MCP Server

The MCP server exposes your AI endpoints as tools that AI agents can discover:

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';

const server = new McpServer({
  name: 'goldbean',
  version: '0.4.1',
});

// Register a paid tool
server.tool(
  'baidu_ocr',
  'Extract text from images using Baidu OCR',
  { image_url: z.string().url() },
  async (params) => {
    // Check payment first
    const paid = await checkPayment(request);
    if (!paid) return paymentRequiredResponse('baidu_ocr', 0.01);

    // Call Baidu OCR
    const result = await baiduOCR(params.image_url);
    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
  }
);

Step 2: Implementing x402 Payment Flow

When an agent calls a paid endpoint without credits, return HTTP 402:

function paymentRequiredResponse(endpoint, priceUsd) {
  return {
    status: 402,
    body: {
      error: 'Payment Required',
      x402: {
        endpoint,
        price: priceUsd.toString(),
        currency: 'USDC',
        chain: 'base',
        contract: '0x833589fCD6e6D11208e4D76B3A0b2E9C0bE017E6',
        receiver: process.env.RECEIVER_WALLET,
        scheme: 'exact'
      }
    }
  };
}

Step 3: Verifying On-Chain Payments

After the agent pays, it retries with a transaction hash. Verify it on Base:

const { Web3 } = require('web3');
const w3 = new Web3('https://mainnet.base.org');

const USDC_CONTRACT = '0x833589fCD6e6D11208e4D76B3A0b2E9C0bE017E6';
const TRANSFER_EVENT = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';

async function verifyPayment(txHash, expectedAmount, receiver) {
  const receipt = await w3.eth.getTransactionReceipt(txHash);
  if (!receipt) return false;

  const transferLog = receipt.logs.find(log =>
    log.address.toLowerCase() === USDC_CONTRACT.toLowerCase() &&
    log.topics[0] === TRANSFER_EVENT &&
    '0x' + log.topics[2].slice(26) === receiver.toLowerCase()
  );

  if (!transferLog) return false;

  // USDC has 6 decimals
  const transferred = BigInt(transferLog.data);
  const expected = BigInt(expectedAmount * 1e6);
  return transferred >= expected;
}

Step 4: Using the x402 SDK

To make it easier for developers, I published an SDK:

npm install @goldbean/x402-sdk

import { GoldBeanClient } from '@goldbean/x402-sdk';

const client = new GoldBeanClient({
  privateKey: process.env.WALLET_PRIVATE_KEY,
  rpcUrl: 'https://mainnet.base.org'
});

// The SDK handles: 402 → pay → retry automatically
const result = await client.call(
  'https://goldbean-api.xyz/paid/baidu-ocr',
  { image_url: 'https://example.com/receipt.jpg' }
);

Step 5: Connecting to Claude Desktop

Add GoldBean as an MCP server:

{
  "mcpServers": {
    "goldbean": {
      "url": "https://goldbean-api.xyz/sse"
    }
  }
}

Claude will discover all 47 tools automatically. Free endpoints work immediately. Paid endpoints return 402 until you add credits.

Pricing Strategy

Tier	Price	Best For
Free	20 credits	Try before you buy
x402	$0.01-$0.03/call	Crypto-native AI agents
PayPal	$1+	International credit card users
Alipay	CNY 7+	China users

The free tier is critical. When users see HTTP 402, they leave. The free tier builds trust before asking for payment.

Discovery Endpoints

GoldBean implements standard discovery endpoints so AI agents can auto-detect capabilities:

/.well-known/x402.json — x402 service discovery
/.well-known/mcp.json — MCP tool listing
/openapi.json — OpenAPI 3.1 specification
llms.txt — LLM-readable service description

These endpoints are essential for interoperability. Tools like Smithery, Glama, and MCP Registry use them to index your service.

Key Lessons

Free tier is not optional — it's survival. Zero conversion on cold 402 responses.
Multi-payment support matters — not everyone has USDC. PayPal and Alipay bridge the gap.
Discovery endpoints drive traffic — being indexed on MCP Registry and awesome-mcp-servers brings organic users.
MCP compatibility is a growth multiplier — Claude Desktop users discover your tools without any marketing.

Try It Now

# Free endpoint - no signup
curl https://goldbean-api.xyz/free/btc-price

# Register for 20 free credits
curl -X POST https://goldbean-api.xyz/paid/user/register

# Connect to Claude Desktop
# Add "url": "https://goldbean-api.xyz/sse" to your MCP config

How to Monetize Baidu AI with x402 and MCP: A Complete Tutorial

GoldBean — Fri, 10 Jul 2026 04:41:52 +0000

The Opportunity

What if you could expose Baidu AI to the entire world, charge per call, and let AI agents pay automatically?

That's exactly what GoldBean does. In this tutorial, I'll show you the architecture and code patterns to monetize any AI API with x402 micropayments and MCP protocol.

Prerequisites

Node.js 20+
Basic understanding of HTTP APIs
A Baidu AI account (or any AI API you want to monetize)
Optional: a crypto wallet with USDC on Base

Architecture: x402 + MCP + Baidu AI

AI Agent (Claude/Cursor) → MCP Protocol (SSE) → GoldBean Server → Baidu AI API
                                    ↓
                            x402 Payment Layer
                            (USDC on Base L2)

The three layers work together:

MCP Layer: AI agents discover and call tools via Model Context Protocol
x402 Layer: Each paid call triggers an HTTP 402 payment flow — agent pays USDC, server verifies on-chain
AI Backend: Baidu AI processes the request and returns results

Step 1: Setting Up the MCP Server

The MCP server exposes your AI endpoints as tools that AI agents can discover:

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';

const server = new McpServer({
  name: 'goldbean',
  version: '0.4.1',
});

// Register a paid tool
server.tool(
  'baidu_ocr',
  'Extract text from images using Baidu OCR',
  { image_url: z.string().url() },
  async (params) => {
    // Check payment first
    const paid = await checkPayment(request);
    if (!paid) return paymentRequiredResponse('baidu_ocr', 0.01);

    // Call Baidu OCR
    const result = await baiduOCR(params.image_url);
    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
  }
);

Step 2: Implementing x402 Payment Flow

When an agent calls a paid endpoint without credits, return HTTP 402:

function paymentRequiredResponse(endpoint, priceUsd) {
  return {
    status: 402,
    body: {
      error: 'Payment Required',
      x402: {
        endpoint,
        price: priceUsd.toString(),
        currency: 'USDC',
        chain: 'base',
        contract: '0x833589fCD6e6D11208e4D76B3A0b2E9C0bE017E6',
        receiver: process.env.RECEIVER_WALLET,
        scheme: 'exact'
      }
    }
  };
}

Step 3: Verifying On-Chain Payments

After the agent pays, it retries with a transaction hash. Verify it on Base:

const { Web3 } = require('web3');
const w3 = new Web3('https://mainnet.base.org');

const USDC_CONTRACT = '0x833589fCD6e6D11208e4D76B3A0b2E9C0bE017E6';
const TRANSFER_EVENT = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';

async function verifyPayment(txHash, expectedAmount, receiver) {
  const receipt = await w3.eth.getTransactionReceipt(txHash);
  if (!receipt) return false;

  const transferLog = receipt.logs.find(log =>
    log.address.toLowerCase() === USDC_CONTRACT.toLowerCase() &&
    log.topics[0] === TRANSFER_EVENT &&
    '0x' + log.topics[2].slice(26) === receiver.toLowerCase()
  );

  if (!transferLog) return false;

  // USDC has 6 decimals
  const transferred = BigInt(transferLog.data);
  const expected = BigInt(expectedAmount * 1e6);
  return transferred >= expected;
}

Step 4: Using the x402 SDK

To make it easier for developers, I published an SDK:

npm install @goldbean/x402-sdk

import { GoldBeanClient } from '@goldbean/x402-sdk';

const client = new GoldBeanClient({
  privateKey: process.env.WALLET_PRIVATE_KEY,
  rpcUrl: 'https://mainnet.base.org'
});

// The SDK handles: 402 → pay → retry automatically
const result = await client.call(
  'https://goldbean-api.xyz/paid/baidu-ocr',
  { image_url: 'https://example.com/receipt.jpg' }
);

Step 5: Connecting to Claude Desktop

Add GoldBean as an MCP server:

{
  "mcpServers": {
    "goldbean": {
      "url": "https://goldbean-api.xyz/sse"
    }
  }
}

Claude will discover all 47 tools automatically. Free endpoints work immediately. Paid endpoints return 402 until you add credits.

Pricing Strategy

Tier	Price	Best For
Free	20 credits	Try before you buy
x402	$0.01-$0.03/call	Crypto-native AI agents
PayPal	$1+	International credit card users
Alipay	CNY 7+	China users

The free tier is critical. When users see HTTP 402, they leave. The free tier builds trust before asking for payment.

Discovery Endpoints

GoldBean implements standard discovery endpoints so AI agents can auto-detect capabilities:

/.well-known/x402.json — x402 service discovery
/.well-known/mcp.json — MCP tool listing
/openapi.json — OpenAPI 3.1 specification
llms.txt — LLM-readable service description

These endpoints are essential for interoperability. Tools like Smithery, Glama, and MCP Registry use them to index your service.

Key Lessons

Free tier is not optional — it's survival. Zero conversion on cold 402 responses.
Multi-payment support matters — not everyone has USDC. PayPal and Alipay bridge the gap.
Discovery endpoints drive traffic — being indexed on MCP Registry and awesome-mcp-servers brings organic users.
MCP compatibility is a growth multiplier — Claude Desktop users discover your tools without any marketing.

Try It Now

# Free endpoint - no signup
curl https://goldbean-api.xyz/free/btc-price

# Register for 20 free credits
curl -X POST https://goldbean-api.xyz/paid/user/register

# Connect to Claude Desktop
# Add "url": "https://goldbean-api.xyz/sse" to your MCP config

Zero to MCP Server in 5 Minutes: A Developer Guide to x402 Micropayments

GoldBean — Thu, 09 Jul 2026 16:50:46 +0000

Why Another MCP Tutorial?

Most MCP Server tutorials show you how to expose a single tool to Claude. But what if you want to expose 47 AI endpoints -- OCR, text-to-speech, LLM chat, image generation -- and charge per call using crypto micropayments?

That is what I built with GoldBean. This article walks through the architecture and shows you how to build your own.

The Stack

Layer	Technology
Protocol	MCP (Model Context Protocol) over SSE
Payments	x402 Protocol -- HTTP 402 to USDC on Base
AI Backend	Baidu AI APIs (OCR, TTS, ASR, LLM, Image Gen)
Runtime	Node.js on VPS
Package	npx goldbean-mcp on npm

How x402 Micropayments Work

The x402 protocol turns HTTP 402 (Payment Required) from an error code into a payment flow:

Client calls a paid endpoint
Server returns 402 Payment Required with payment details (USDC amount, wallet address, chain ID)
Client pays 0.01 USDC on Base mainnet via their wallet
Client retries the request with the transaction hash
Server verifies the on-chain transaction and returns the API response

No API key. No registration. No monthly subscription. You pay per call.

Adding MCP Layer

The MCP protocol sits on top of the HTTP server. Clients connect via SSE. Claude Desktop config:

The tools/list response includes all available tools with their input schemas. GoldBean exposes 10 tools through MCP: baidu_ocr, baidu_tts, ai_chat, image_gen, translate, weather, web_search, eth_price, btc_price, and code_run.

Free Tier Strategy

Here is the key insight: users who see HTTP 402 leave. Conversion rates for payment-required APIs are near zero.

So GoldBean offers:

21 free endpoints (no payment needed): weather, crypto prices, web search, translation, code runner
20 free credits for paid endpoints (OCR, TTS, LLM, Image Gen)
After free credits: 0.01 to 0.08 USD per call via USDC, PayPal, or Alipay

The free tier is the acquisition funnel. Users try it, find it useful, then pay when they need more.

Quick Start

Or add to Claude Desktop config:

That is it. No API key, no registration, no credit card. 20 free credits to start.

What I Learned Building This

1. Zero conversion is the real problem. Having a working payment system does not mean people will pay. The 402 response scares users away. The free tier exists to build trust before asking for payment.

2. MCP discovery matters. Being listed on Smithery, Glama, and awesome-mcp-servers drives organic traffic.

3. Multi-payment options are essential. Not everyone has USDC. PayPal and Alipay are necessary for global reach.

DEV Community: GoldBean

2026 Chinese LLM API Benchmark: 7 Models Ranked by Real Data (July Update)

2026 Chinese LLM API Benchmark: 7 Models Tested with Real Data

Why Benchmark Now?

Overall Scores (Bonree Data 2026.05)

Key Findings

Model Profiles

DeepSeek-v4-pro (81.1 overall, Best Value)

Kimi K2.6 Thinking (90.0 hallucination control)

Doubao Seed2.0-pro (85.7 code generation)

Unified Gateway: Why Not Just Pick One?

Try the Playground

Data Source

2026 Chinese LLM API Benchmark: 7 Models Tested with Real Data

2026 Chinese LLM API Benchmark: 7 Models Tested with Real Data

Why Benchmark Now?

Overall Scores (Bonree Data 2026.05)

Key Findings

Model Profiles

DeepSeek-v4-pro (81.1 overall, Best Value)

Kimi K2.6 Thinking (90.0 hallucination control)

Doubao Seed2.0-pro (85.7 code generation)

Unified Gateway: Why Not Just Pick One?

Try the Playground

Data Source

GoldBean API: Use Baidu AI Without a Chinese Phone Number

The Problem: Baidu Cloud Is Powerful, But Inaccessible

What Is GoldBean API?

Quick Start: OCR in 30 Seconds

cURL

Python (requests)

Quick Start: Translation

cURL

Python (requests)

Pricing: Transparent and Predictable

How does this compare to Baidu Cloud direct?

LLM Access: OpenAI-Compatible Qianfan Models

Who Is This For?

Conclusion

Build a Chinese AI MCP Server with x402 Micropayments: My Journey Creating GoldBean

The Problem

The Solution: GoldBean MCP Server

How x402 Works (Under the Hood)

Architecture

Getting Started

1. Install as MCP Server

2. For Free Tier (No Wallet Needed)

3. For Paid Tier (USDC on Base)

4. For Prepaid Credits (PayPal / Alipay)

Real-World Use Cases

OCR Pipeline for Chinese Documents

Multi-Language Translation Agent

ERNIE LLM Integration

Pricing

Why MCP + x402 Matters

Links

Baidu OCR API: 19 Recognition Scenarios From Handwriting to Medical Receipts

What You'll Need

The 19 OCR Scenarios at a Glance

Quick Start: 5-Minute Integration

Node.js

Python

Deep Dive: 5 Most Useful Scenarios

1. Handwriting Recognition

2. Mathematical Formula Recognition

3. Table Extraction

4. Medical Receipt Processing

5. ID Card Recognition

Using with MCP (Model Context Protocol)

Pricing

Error Handling Best Practices

Tips for Best Results

Conclusion

67 Baidu AI Endpoints Behind a Single REST API â No Chinese Phone Needed

What's Inside

Quick Start

1. Free Tier â€” No Signup Required

2. Paid Tier â€” Pay Per Call

3. MCP Server â€” For AI Agents

Payment Options