DEV Community: GoldBean

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.

Building GoldBean: How I Created a Pay-Per-Call MCP Server with x402 Micropayments

GoldBean — Thu, 09 Jul 2026 16:42:03 +0000

Building GoldBean: How I Created a Pay-Per-Call MCP Server with x402 Micropayments

When AI agents need to call an API — OCR, text-to-speech, a language model — there's no simple "pay as you go" option. You sign up, create an API key, add a credit card, and commit to a monthly plan. For autonomous agents that make occasional calls, that's overkill. For developers building agent pipelines, it's friction at every step.

I built GoldBean to fix this: an MCP (Model Context Protocol) server that exposes 47 Baidu AI endpoints — 26 paid, 21 free — where payments happen per-call via the x402 protocol using USDC on Base. No API key, no registration, no monthly commitment. Just pay per call.

The Problem

Here's the friction every AI agent developer hits:

API key management: Every AI service requires registration, email verification, and API key generation. Agents need to store and rotate these keys securely.
Monthly subscriptions: Most AI APIs are priced as SaaS subscriptions. An agent making 50 calls/month shouldn't pay $29/month.
Credit card requirements: International developers — especially those outside the US/EU — often can't get approved for credit card-based billing. China-based AI APIs like Baidu's require a Chinese phone number for registration.
No native agent payment: Existing payment infrastructure (Stripe, PayPal) was designed for humans clicking buttons in browsers, not for autonomous agents making machine-to-machine API calls.

The gap is clear: agents need a way to pay for API calls programmatically, at the granularity of a single request, without human intervention.

The Solution: GoldBean MCP Server

GoldBean bridges this gap by combining three technologies:

MCP (Model Context Protocol): An open standard that lets AI agents like Claude discover and call external tools. GoldBean exposes its 47 endpoints as MCP tools via SSE transport.
x402 Payment Protocol: An HTTP-native micropayment standard. When an agent calls a paid endpoint without sufficient credits, the server returns HTTP 402 (Payment Required) with payment instructions. The agent pays USDC on Base L2, and the server verifies the on-chain transaction before returning the result.
Baidu AI APIs: A rich suite of AI services — OCR, TTS, ASR, LLM, image generation — that GoldBean wraps and exposes with unified billing.

The result: an AI agent can discover GoldBean's tools via MCP, call a free endpoint immediately, or pay $0.01–$0.05 per call via crypto for premium endpoints — all without a single API key or registration form.

Architecture Overview

┌─────────────────────────────────────────────────────┐
│                   AI Agent (Claude)                  │
│              MCP Client (SSE transport)               │
└──────────────────────┬──────────────────────────────┘
                       │
                       │ SSE connection to /sse
                       ▼
┌─────────────────────────────────────────────────────┐
│              GoldBean MCP Server (Node.js)            │
│                                                      │
│  ┌─────────┐  ┌──────────────┐  ┌────────────────┐  │
│  │ MCP     │  │ x402 Payment  │  │ Baidu AI       │  │
│  │ Protocol │  │ Middleware    │  │ Integration    │  │
│  │ (SSE)   │  │ (HTTP 402)    │  │ (OCR/TTS/LLM)  │  │
│  └─────────┘  └──────────────┘  └────────────────┘  │
│                                                      │
│  ┌──────────────────────────────────────────────┐   │
│  │         Unified Payment Layer                │   │
│  │  x402 (USDC/Base) | PayPal | Alipay          │   │
│  └──────────────────────────────────────────────┘   │
└──────────────────────┬──────────────────────────────┘
                       │
                       │ nginx reverse proxy
                       ▼
              goldbean-api.xyz (VPS)

Key components:

goldbean-mcp-server.js — MCP protocol handler that exposes 47 tools via SSE transport
goldbean-x402-middleware.js — x402 payment middleware: EIP-3009 signature verification + on-chain transfer verification + 18 pricing endpoints
goldbean-unified-payment.js — Unified payment entry point routing between x402, PayPal, and Alipay
goldbean-pricing.js — Centralized pricing configuration (PRICE_MAP)
server.js — Main Express server (v8.0.0, ~970 lines) wiring everything together

Deployed on a VPS running AlmaLinux with Node.js and nginx as a reverse proxy. The server handles MCP discovery, payment verification, and API proxying in a single process.

How x402 Works — Technical Deep Dive

The x402 protocol turns HTTP 402 — a status code that has existed since 1991 but was never actually used — into a machine-readable payment negotiation. Here's the flow:

1. Agent calls a paid endpoint

POST /paid/baidu-ocr
Content-Type: application/json
x-user-id: anon_7f3a2b

{ "image_url": "https://example.com/receipt.jpg" }

2. Server returns HTTP 402 with payment requirements

If the user has no credits, the server responds with:

HTTP/1.1 402 Payment Required
Content-Type: application/json

{
  "error": "Payment Required",
  "x402": {
    "endpoint": "/paid/baidu-ocr",
    "price": "0.01",
    "currency": "USDC",
    "chain": "base",
    "contract": "0x833589fCD6e6D11208e4D76B3A0b2E9C0bE017E6",
    "receiver": "0x7484...7D98",
    "scheme": "exact"
  },
  "message": "Pay 0.01 USDC on Base to unlock this call"
}

3. Agent pays USDC on Base

The agent (or its wallet facilitator) constructs a transfer:

// Using @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: amount calculation → ERC-20 transfer → tx hash generation
const txHash = await client.pay({
  endpoint: '/paid/baidu-ocr',
  amount: '0.01',
  receiver: '0x7484...7D98'
});

4. Server verifies the on-chain transaction

The x402 middleware (goldbean-x402-middleware.js) performs three checks:

async function verifyOnChainTx(txHash, expectedAmount, receiver) {
  // 1. Fetch the transaction receipt from Base RPC
  const receipt = await web3.eth.getTransactionReceipt(txHash);

  // 2. Verify it's a USDC transfer to our wallet
  const transferLog = receipt.logs.find(log => 
    log.topics[0] === TRANSFER_EVENT_SIG &&
    '0x' + log.topics[2].slice(26) === receiver.toLowerCase()
  );

  // 3. Verify the amount matches the endpoint price
  const transferred = web3.utils.toBN(transferLog.data);
  const expected = web3.utils.toBN(
    web3.utils.toWei(expectedAmount, 'mwei') // USDC has 6 decimals
  );

  return transferred.gte(expected);
}

5. Server returns the API response

Once verified, the server grants a temporary credit and proxies the request to Baidu's API:

{
  "words_result": [
    { "words": "Total: $42.50" },
    { "words": "Date: 2025-07-09" }
  ],
  "words_result_num": 2,
  "log_id": 1752453617
}

The entire flow — from 402 response to payment to API result — takes ~3–5 seconds on Base L2.

Getting Started

Option 1: MCP Server for Claude Desktop

Add GoldBean to your Claude Desktop config:

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

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

Option 2: Direct API Call

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

# Call a free endpoint (no payment needed)
curl https://goldbean-api.xyz/free/btc-price

# Call a paid endpoint using your user ID
curl https://goldbean-api.xyz/paid/baidu-ocr \
  -H "x-user-id: YOUR_USER_ID" \
  -H "Content-Type: application/json" \
  -d '{"image_url": "https://example.com/image.jpg"}'

Option 3: Python Integration with x402

import requests
from web3 import Web3

# Step 1: Call the endpoint
resp = requests.post(
    "https://goldbean-api.xyz/paid/baidu-ocr",
    json={"image_url": "https://example.com/receipt.jpg"}
)

# Step 2: If 402, handle payment
if resp.status_code == 402:
    payment_info = resp.json()["x402"]

    # Pay USDC on Base via web3.py
    w3 = Web3(Web3.HTTPProvider("https://mainnet.base.org"))
    usdc = w3.eth.contract(
        address="0x833589fCD6e6D11208e4D76B3A0b2E9C0bE017E6",
        abi=ERC20_ABI
    )

    # Transfer 0.01 USDC (6 decimals)
    tx = usdc.functions.transfer(
        payment_info["receiver"],
        10000  # 0.01 USDC in base units
    ).build_transaction({
        "from": w3.eth.account.address,
        "nonce": w3.eth.get_transaction_count(w3.eth.account.address),
        "gas": 80000,
        "gasPrice": w3.eth.gas_price
    })

    signed = w3.eth.account.sign_transaction(tx, PRIVATE_KEY)
    tx_hash = w3.eth.send_raw_transaction(signed.rawTransaction)

    # Step 3: Retry with payment proof
    resp = requests.post(
        "https://goldbean-api.xyz/paid/baidu-ocr",
        json={"image_url": "https://example.com/receipt.jpg"},
        headers={"x-tx-hash": tx_hash.hex()}
    )

print(resp.json())

Option 4: x402 SDK (Node.js)

npm install @goldbean/x402-sdk

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

const client = new GoldBeanClient({
  privateKey: process.env.PRIVATE_KEY,
  // Automatically handles 402 → pay → retry
});

const result = await client.call(
  'https://goldbean-api.xyz/paid/baidu-ocr',
  { image_url: 'https://example.com/image.jpg' }
);

Available Endpoints

GoldBean exposes 47 endpoints — 26 paid and 21 free:

Paid Endpoints (26)

Category	Endpoint	Price	Description
OCR	`/paid/baidu-ocr`	$0.01	General text recognition
OCR	`/paid/ocr-medical`	$0.01	Medical document OCR
OCR	`/paid/ocr-education`	$0.01	Exam/handwriting OCR
OCR	`/paid/ocr-table`	$0.01	Table structure recognition
TTS	`/paid/tts`	$0.02	Text-to-speech (10+ voices)
ASR	`/paid/asr`	$0.02	Speech-to-text
ASR	`/paid/asr-diarization`	$0.03	Speaker diarization
LLM	`/paid/llm-chat`	$0.03	ERNIE 4.0 / Qwen / DeepSeek
LLM	`/paid/llm-embeddings`	$0.02	Text embeddings
Image Gen	`/paid/image-gen`	$0.03	Stable Diffusion XL
Image Gen	`/paid/image-enhance`	$0.02	Image quality enhancement
NLP	`/paid/sentiment`	$0.01	Sentiment analysis
NLP	`/paid/keyword-extract`	$0.01	Keyword extraction
NLP	`/paid/summary`	$0.02	Text summarization
NLP	`/paid/translation`	$0.01	Multi-language translation
Vision	`/paid/image-classify`	$0.02	Image classification
Vision	`/paid/object-detect`	$0.02	Object detection
Vision	`/paid/face-detect`	$0.02	Face detection
Document	`/paid/doc-parser`	$0.03	Document structure parsing
Document	`/paid/id-card-ocr`	$0.01	ID card recognition
Document	`/paid/bank-card-ocr`	$0.01	Bank card recognition
Document	`/paid/business-license`	$0.01	Business license OCR
Data	`/paid/ssi-verify`	$0.05	SSI verification
Data	`/paid/data-extract`	$0.02	Unstructured data extraction
API	`/paid/qrcode-gen`	$0.01	QR code generation
API	`/paid/qrcode-parse`	$0.01	QR code parsing

Free Endpoints (21)

Category	Endpoint	Description
Crypto	`/free/btc-price`	Bitcoin price
Crypto	`/free/eth-price`	Ethereum price
Crypto	`/free/gas-price`	Current gas price
Utility	`/free/ip-lookup`	IP geolocation
Utility	`/free/exchange-rate`	Currency exchange rates
Utility	`/free/timestamp`	Unix timestamp converter
Utility	`/free/uuid-gen`	UUID generator
Utility	`/free/hash-gen`	Hash generator (MD5/SHA256)
Utility	`/free/base64-encode`	Base64 encoder
Utility	`/free/base64-decode`	Base64 decoder
Utility	`/free/url-encode`	URL encoder
Utility	`/free/url-decode`	URL decoder
Utility	`/free/json-format`	JSON formatter
Utility	`/free/regex-test`	Regex tester
Utility	`/free/color-convert`	Color format converter
Utility	`/free/lorem-ipsum`	Lorem ipsum generator
Utility	`/free/user-agent`	User agent parser
Utility	`/free/cron-parser`	Cron expression parser
Utility	`/free/jwt-decode`	JWT decoder
Utility	`/free/markdown-to-html`	Markdown to HTML
Utility	`/free/slugs-gen`	Slug generator

What I Learned

x402 Protocol Implementation

The x402 spec is conceptually elegant — reuse HTTP 402 for machine-to-machine payments. But the implementation details are non-trivial:

USDC has 6 decimals, not 18. A $0.01 payment is 10000 base units, not 10000000000000000. Getting this wrong means payments fail silently or overcharge by 10^12.
EIP-3009 signature verification (used for gasless meta-transactions) required implementing transferWithAuthorization signature validation. I extracted this logic into the @goldbean/x402-sdk so others can reuse it.
On-chain verification latency: querying a Base RPC for transaction receipts adds ~1–2 seconds. I cache verified transactions to avoid re-verifying on retries.

The Zero Conversion Rate Problem

This was the hardest lesson. In the first 30 days, I saw real traffic — IP 47.82.11.57 (Safari/macOS) hit the paid /paid/ssi-verify endpoint. The server returned 402. The user left.

When a human sees "Payment Required," they bounce. When an agent sees 402, it needs a wallet with USDC and the logic to complete payment — and most agents don't have that yet.

The lesson: free tier as acquisition strategy is not optional — it's survival. The 21 free endpoints exist specifically to let users experience the product before committing to payment. The 20 free credits given at registration serve the same purpose for paid endpoints.

Multi-Payment Support as a Bridge

Not every developer has a crypto wallet. So GoldBean supports three payment methods:

x402 (USDC on Base) — for crypto-native agents and developers
PayPal — for international users with credit/debit cards
Alipay — for China users

The unified payment layer (goldbean-unified-payment.js) routes between these three. This means a developer in San Francisco can pay with PayPal while their agent pays with USDC — same endpoint, different payment rails.

Deployment on a Budget VPS

GoldBean runs on a 1GB RAM VPS ($5/month). The main constraint is memory — Node.js + nginx + monitoring scripts compete for limited RAM. I had to:

Tune nginx worker connections to 512
Use --max-old-space-size=384 for Node.js
Run monitoring scripts on cron rather than as persistent daemons

The architecture (single Node.js process handling MCP + payments + API proxy) works because the workload is I/O-bound (waiting on Baidu APIs and blockchain RPCs), not CPU-bound.

Try It

GoldBean is live and free to try. Here's what you can do right now:

Browse free endpoints — No signup needed:

   curl https://goldbean-api.xyz/free/btc-price

Register for 20 free credits — Use them on any paid endpoint:

   curl -X POST https://goldbean-api.xyz/paid/user/register

Connect to Claude Desktop — Add the MCP server and let Claude discover all 47 tools:

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

Install the x402 SDK — For programmatic payments in your own agent:

   npm install @goldbean/x402-sdk

How to Build a Pay-Per-Call AI API Market with x402 and MCP Protocol

GoldBean — Thu, 09 Jul 2026 16:33:37 +0000

Why Pay-Per-Call?

Most AI API platforms force you into monthly subscriptions. But what if you only need to call an OCR endpoint once? Or run a single image recognition task?

That's why I built GoldBean — a pay-per-call AI API market where you only pay for what you use ($0.01-$0.03 per call).

Architecture Overview

GoldBean runs on a single VPS with:

Node.js server handling API requests (port 9879)
MCP HTTP bridge for Model Context Protocol compatibility (port 3099)
Nginx reverse proxy with SSL termination
Three payment gateways: PayPal, Alipay, USDC (on-chain via x402)

The x402 Payment Protocol

x402 is the key innovation. Here's how it works:

Client sends an API request with an EIP-3009 signed transfer
Server verifies the signature and checks the payment amount
If valid, server executes the API call and returns the result
The entire flow takes less than 2 seconds with near-zero fees

// Client side: signing the payment
const transfer = {
  to: merchantAddress,
  value: priceInWei,
  validAfter: 0,
  validBefore: Math.floor(Date.now() / 1000) + 3600,
  nonce: randomNonce()
};
const signature = await signer._signTypedData(domain, types, transfer);

MCP Server Integration

GoldBean is fully compatible with the Model Context Protocol. You can plug it directly into Claude, Cursor, or any MCP-capable AI tool:

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

Once connected, your AI assistant can call 47 different AI endpoints — OCR, image recognition, speech synthesis, LLM chat, image generation — without writing any code.

47 Endpoints

Here are some of the key API categories:

OCR: general text, handwriting, table recognition, medical documents
Image Recognition: object detection, scene analysis, logo recognition
Speech: text-to-speech with multiple voices, speech-to-text
LLM: chat completions, text generation, summarization
Image Generation: AI-powered image creation

All accessible via a single API key with pay-per-call pricing.

Free Tier

Every user gets 50 free API calls per day. No credit card required to start.

DEV Community: GoldBean

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

Membership Plans (v9.7.0)

Real-World Examples

OCR: Extract Text from a Receipt

LLM Chat: ERNIE 4.0

TTS: Text-to-Speech

Why Not Just Use Baidu Directly?

Links

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

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

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

Monetize Any AI API with x402 Micropayments and MCP Protocol

The Opportunity

Prerequisites

Architecture: x402 + MCP + Baidu AI

Step 1: Setting Up the MCP Server

Step 2: Implementing x402 Payment Flow

Step 3: Verifying On-Chain Payments

Step 4: Using the x402 SDK

Step 5: Connecting to Claude Desktop

Pricing Strategy

Discovery Endpoints

Key Lessons

Try It Now

Links