DEV Community: goldbean

From Free to Paid: Engineering a Monetized MCP Server with 16 AI Tools in Production

goldbean — Wed, 08 Jul 2026 13:39:50 +0000

Last month we launched GoldBean, a pay-per-call MCP server with 100+ AI tools. The most common question I get: 'How did you actually build the payment layer?'

Here's a technical deep dive into how we implemented x402 micropayments on top of an MCP server.

The Problem

Most MCP servers are free. That's great for open source, but it creates a tragedy of the commons: nobody maintains them, API costs go unpaid, and quality degrades.

We wanted to prove that a pay-per-call model could work for AI tool aggregation — where developers pay only for what they use, and the underlying API costs are transparently passed through.

Architecture Overview

Claude Desktop → MCP Client → GoldBean Server
                                    ↓
                              Payment Gateway
                                    ↓
                          x402 (Base USDC) / PayPal / Alipay
                                    ↓
                            Baidu AI / Other Providers

Step 1: The MCP Server Skeleton

We built on top of the standard MCP SDK. Each tool gets a price metadata field:

{
  name: "ocr",
  description: "Extract text from images",
  price: 0.01,  // USD
  inputSchema: { ... }
}

Step 2: x402 Payment Verification

The x402 protocol is elegant: HTTP 402 Payment Required, natively.

Flow:

First request — no payment header → Server returns 402 + payment details
Second request — client includes X-PAYMENT header with EIP-3009 signed transfer
Verification — server checks on-chain that the transfer is valid and not replayed
Execution — if payment OK, run the tool and return results

Key code snippet (Node.js):

const verifyPayment = async (paymentHeader) => {
  const { transferWithAuth } = decodePayment(paymentHeader);

  const valid = await contract.methods.validateTransfer(transferWithAuth).call();
  const used = await db.get(`nonce:${transferWithAuth.nonce}`);
  if (used) throw new Error('Replay detected');
  await db.set(`nonce:${transferWithAuth.nonce}`, true);

  return valid;
};

Step 3: PayPal and Alipay Fallback

Not everyone wants crypto. We added traditional payment rails:

PayPal — Standard checkout flow, credits added to account
Alipay — QR code payment, same credit system

Credits are stored server-side and deducted per call. When credits run out, the client gets a 402 response with instructions to top up.

Step 4: MCP Tool Registration

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    { name: "ocr", description: "Extract text", price: 0.01, freeQuota: 50, inputSchema: { ... } },
    // ... 15 more tools
  ]
}));

Step 5: The Free Tier Hook

Data so far:

~80% of users stay within free tier
~15% exceed free tier but don't pay (wait for next day)
~5% convert to paid

The free tier is a loss leader, but it builds trust.

Challenges We Hit

Nonce replay attacks — Fixed with Redis-backed nonce storage
Chain reorgs on Base — Wait for 2 block confirmations
Price volatility — Daily price cache updates
Client UX — Claude Desktop doesn't show prices, added tool-info endpoint

Lessons Learned

MCP is the perfect distribution channel for APIs
x402 micropayments can work when invisible to users
Free tiers are essential — 80% never pay, but spread the word
Aggregation > Individual APIs

Try It Out

MCP endpoint: https://goldbean-api.xyz/sse
Docs: https://goldbean-api.xyz
npm SDK: npm install @goldbean/x402-sdk
Server source: https://github.com/wuzenghai616-lang/goldbean

How We Built a Monetized MCP Server with x402 Micropayments: Technical Deep Dive

goldbean — Wed, 08 Jul 2026 13:38:01 +0000

Last month we launched GoldBean, a pay-per-call MCP server with 100+ AI tools. The most common question I get: 'How did you actually build the payment layer?'

Here's a technical deep dive into how we implemented x402 micropayments on top of an MCP server.

The Problem

Most MCP servers are free. That's great for open source, but it creates a tragedy of the commons: nobody maintains them, API costs go unpaid, and quality degrades.

We wanted to prove that a pay-per-call model could work for AI tool aggregation — where developers pay only for what they use, and the underlying API costs are transparently passed through.

Architecture Overview

Claude Desktop → MCP Client → GoldBean Server
                                    ↓
                              Payment Gateway
                                    ↓
                          x402 (Base USDC) / PayPal / Alipay
                                    ↓
                            Baidu AI / Other Providers

Step 1: The MCP Server Skeleton

We built on top of the standard MCP SDK. Each tool gets a price metadata field:

{
  name: "ocr",
  description: "Extract text from images",
  price: 0.01,  // USD
  inputSchema: { ... }
}

Step 2: x402 Payment Verification

The x402 protocol is elegant: HTTP 402 Payment Required, natively.

Flow:

First request — no payment header → Server returns 402 + payment details
Second request — client includes X-PAYMENT header with EIP-3009 signed transfer
Verification — server checks on-chain that the transfer is valid and not replayed
Execution — if payment OK, run the tool and return results

Key code snippet (Node.js):

// Verify EIP-3009 signed transfer on Base
const verifyPayment = async (paymentHeader) => {
  const { transferWithAuth } = decodePayment(paymentHeader);

  // Check on-chain state
  const valid = await contract.methods.validateTransfer(TransferWithAuth).call();

  // Anti-replay: check nonce not used before
  const used = await db.get(`nonce:${transferWithAuth.nonce}`);
  if (used) throw new Error('Replay detected');

  // Mark nonce as used
  await db.set(`nonce:${transferWithAuth.nonce}`, true);

  return valid;
};

Step 3: PayPal and Alipay Fallback

Not everyone wants crypto. We added traditional payment rails:

PayPal — Standard checkout flow, credits added to account
Alipay — QR code payment, same credit system

Credits are stored server-side and deducted per call. When credits run out, the client gets a 402 response with instructions to top up.

Step 4: MCP Tool Registration

Each tool is registered with both MCP metadata and a price:

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "ocr",
      description: "Extract text from images and PDFs",
      price: 0.01,
      freeQuota: 50,  // free calls per day
      inputSchema: { ... }
    },
    // ... 15 more tools
  ]
}));

The client (Claude Desktop) sees these tools in the tool picker. When a tool is called, the server checks if the user has free quota or valid payment.

Step 5: The Free Tier Hook

This was crucial. 50 free calls/day lets developers experiment without friction.

Data so far:

~80% of users stay within free tier
~15% exceed free tier but don't pay (they just wait for next day)
~5% convert to paid (still small, but growing)

The free tier is a loss leader, but it builds trust and gets users into the habit of using the tools.

Challenges We Hit

1. Nonce replay attacks
Early versions didn't properly track nonces. Fixed with Redis-backed nonce storage.

2. Chain reorgs on Base
A transfer could be valid in one block but reorged out in the next. We now wait for 2 block confirmations before accepting payment.

3. Price volatility
USDC is stable, but API provider prices change. We added a price cache layer that updates daily from provider rate cards.

4. Client UX
Claude Desktop doesn't show prices in the tool picker. We added a tool-info custom endpoint that returns pricing info, and we prompt users in the first interaction.

Lessons Learned

MCP is the perfect distribution channel for APIs — No SDKs to maintain, just one endpoint
x402 micropayments can work — The key is making them invisible to the user
Free tiers are essential — 80% of users never pay, but they spread the word
Aggregation > Individual APIs — One endpoint, one bill, 100+ tools

Try It Out

MCP endpoint: https://goldbean-api.xyz/sse
Docs: https://goldbean-api.xyz
npm SDK: npm install @goldbean/x402-sdk
Server source: https://github.com/wuzenghai616-lang/goldbean

If you're building MCP servers or exploring micropayments for APIs, I'd love to hear your approach in the comments.

I Built a Pay-Per-Call MCP Server That Aggregates 100+ AI Tools — Here's What I Learned

goldbean — Wed, 08 Jul 2026 12:14:02 +0000

When I first heard about the Model Context Protocol (MCP), I thought: finally, a standard way for AI assistants to call external tools. But the more I used MCP servers, the more I noticed a gap — most were free community utilities with no monetization model. That's great for open source, but it doesn't incentivize high-quality, maintained endpoints.

So I built GoldBean — a pay-per-call MCP server that aggregates 100+ AI tools behind a single endpoint, with micropayments via the x402 protocol.

What GoldBean Does

GoldBean exposes 16 MCP tools (with 100+ sub-capabilities) including:

OCR — Extract text from images and PDFs (Baidu's engine, 50+ languages)
Text-to-Speech — 100K characters per request, multiple voices
Speech Recognition — Audio to text with speaker diarization
Image Generation — Text-to-image with style control
LLM Chat — Multi-model chat completions
Translation — 200+ language pairs
Object Recognition — Image content analysis
And 90+ more capabilities

The Pay-Per-Call Model

Here's the pricing breakdown:

Tool	Price per Call
OCR	$0.01
LLM Chat	$0.03
Image Generation	$0.03
TTS	$0.02
ASR	$0.02

Free tier: 50 calls/day, no credit card required.

How x402 Micropayments Work

The x402 protocol enables HTTP 402 (Payment Required) natively:

Client sends a request without payment
Server responds with HTTP 402 + payment details (recipient address, amount, chain)
Client signs an EIP-3009 transfer and resends with the payment header
Server verifies the on-chain transaction and fulfills the request

This happens in milliseconds — the user never leaves the flow. We use Base mainnet for low gas fees, and payments settle in USDC.

For non-crypto users, we also accept PayPal and Alipay.

Connecting to Claude Desktop

Add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "goldbean": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sse", "https://goldbean-api.xyz/sse"]
    }
  }
}

Restart Claude Desktop, and you'll see all 16 tools appear in the tool picker.

Real-World Use Case

Last week I needed to:

Extract text from a 20-page scanned Chinese PDF
Translate the summary to English
Generate a voiceover for the English version
Create a cover image

Instead of signing up for 4 different services, I just asked Claude to do it — all through GoldBean. Total cost: $0.08.

What I Learned Building This

1. MCP is the perfect distribution channel for APIs. Instead of building SDKs for every language, you just expose an MCP endpoint and any AI assistant can use your tools.

2. Micropayments can work for APIs. The key insight is that x402 makes the payment flow invisible — the client SDK handles it automatically. Users don't need to think about crypto.

3. Free tiers are essential. 50 free calls/day lets developers experiment without friction. Most never need to pay.

4. Aggregation creates value. Developers don't want 10 API keys and 10 billing dashboards. One endpoint, one bill.

Try It Out

MCP endpoint: https://goldbean-api.xyz/sse
Documentation: https://goldbean-api.xyz
npm SDK: npm install @goldbean/x402-sdk
Also available on: MCPize | Glama | Smithery

If you're building with MCP or exploring micropayments for APIs, I'd love to hear your thoughts in the comments.

How to Connect Claude Desktop to 100+ AI Tools Using a Single MCP Server

goldbean — Wed, 08 Jul 2026 11:13:19 +0000

If you're using Claude Desktop for coding, research, or content creation, you probably know about MCP (Model Context Protocol) servers. They let Claude call external tools — but most MCP servers only do one thing. Today I'll show you how to connect Claude Desktop to a single MCP server that gives you access to 100+ AI tools, from OCR to text-to-speech to image generation.

What is GoldBean?

GoldBean is a pay-per-call MCP server that aggregates AI tools from multiple providers. Instead of managing 10 different API keys and billing dashboards, you connect once and Claude can route tool calls to the right backend service automatically.

Supported tools include:

OCR (document & image text extraction)
TTS (text-to-speech)
ASR (automatic speech recognition)
Translation
LLM Chat
Image recognition & generation
And 90+ more

Connecting Claude Desktop

Open Claude Desktop and go to Settings → Developer → Edit Config
Add the following MCP server configuration:

{
  "mcpServers": {
    "goldbean": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sse", "https://goldbean-api.xyz/sse"]
    }
  }
}

Restart Claude Desktop. You should see the GoldBean tools appear in the tool picker.

How Pricing Works

GoldBean uses a pay-per-call model:

Free tier: 50 calls per day
Paid calls: As low as $0.01 per request
Payment methods: Base USDC (via x402 protocol), PayPal, or Alipay
No KYC required for crypto payments

This means you can experiment for free, and only pay when you scale beyond the daily limit.

Example Use Case

I recently needed to extract text from a 20-page scanned PDF, generate a voiceover for the summary, and translate it to Spanish. Instead of signing up for three separate services, I just asked Claude to do it — all through the GoldBean MCP server.

Try It Out

MCP endpoint: https://goldbean-api.xyz/sse
Full documentation: https://goldbean-api.xyz
Also available on: MCPize | Glama | Smithery

Have you tried building with MCP servers yet? Drop a comment with your favorite use case.

This post was written to share a useful developer tool I built. No affiliation with Claude Desktop or Anthropic.

x402 Micropayments for AI Agents: A Step-by-Step Tutorial (2026)

goldbean — Sat, 04 Jul 2026 05:19:01 +0000

What is x402 and Why Should You Care?

You've probably seen HTTP 402 Payment Required in old HTTP spec docs and wondered what it's for. Turns out, it was waiting for AI agents.

x402 is a protocol where an API returns 402 Payment Required with a price instead of denying access. Your AI agent reads the price, attaches a USDC payment (one microtransaction on Base network), and gets the data. No API keys, no monthly subscriptions, no signup flow.

But the real magic? AI agents can discover and pay for APIs autonomously — no human in the loop.

How x402 Works in Practice

Here's the flow:

1. Agent → API:    GET /data
2. API → Agent:    402 Payment Required — $0.01
3. Agent → Chain:  Signed USDC transfer (Base network)
4. Agent → API:    GET /data (with x402-payment header)
5. API → Agent:    200 OK + response data

The whole round trip takes about 2 seconds.

Step 1: Discover x402 Endpoints

Before your agent can call APIs, it needs to find them. The x402 ecosystem has several discovery services:

Circle Agent Marketplace (42 services, 644 endpoints):

https://agents.circle.com/services

402 Index (protocol-agnostic directory):

https://402index.io

BlockRun (600+ indexed x402 services):

https://blockrun.ai/marketplace

Most x402 services also expose a /.well-known/x402-bazaar endpoint listing supported currencies, pricing, and wallet addresses:

curl -s https://goldbean-api.xyz/.well-known/x402-bazaar | jq

Which returns:

{
  "name": "GoldBean API",
  "version": "8.0.0",
  "currencies": [
    {
      "id": "USDC",
      "network": "base",
      "decimals": 6,
      "contract": "0x833589fcd6edb6e08f4c7c32d4f71b54bdA02913"
    }
  ],
  "pricing": {
    "standard": { "price": 0.99, "currency": "USDC", "unit": "per request" },
    "bulk_100": { "price": 49, "currency": "USDC", "unit": "100 requests", "valid_days": 30 },
    "bulk_500": { "price": 199, "currency": "USDC", "unit": "500 requests", "valid_days": 90 }
  },
  "payment_methods": ["x402", "paypal", "alipay"],
  "wallet": "0x7484b0bca25d2ee56e9b0535572d4cf44a047d98",
  "network": "eip155:8453",
  "endpoint": "https://goldbean-api.xyz"
}

Step 2: Pay with x402 via curl

First, check the price by sending a request without payment:

curl -v -X POST "https://goldbean-api.xyz/paid/baidu-ocr-accurate" \
  -F "image=@test.jpg"

You'll get a 402 Payment Required with the exact price.

To pay, sign a USDC transfer on Base network using your wallet. Here's the x402 header format:

x402-payment: <signed-transaction-hex>

For automated payments, use the Circle SDK:

npm i @circle-fin/x402-batching

import { createClientMiddleware } from "@circle-fin/x402-batching/client";

const client = createClientMiddleware({
  signer: myWalletSigner,
});

const response = await fetch("https://goldbean-api.xyz/paid/baidu-ocr-accurate", {
  method: "POST",
  body: formData,
  ...client,
});

const result = await response.json();

No API keys. No signup. Just a wallet and USDC.

Step 3: Build an x402 Agent in Python

Here's a complete AI agent that calls Baidu OCR via x402, running in a loop to process documents:

import requests
from web3 import Web3
import json

# Connect to Base
w3 = Web3(Web3.HTTPProvider("https://mainnet.base.org"))
account = w3.eth.account.from_key("YOUR_PRIVATE_KEY")

# USDC contract on Base
USDC = "0x833589fcd6edb6e08f4c7c32d4f71b54bdA02913"
usdc = w3.eth.contract(
    address=USDC,
    abi=[{"constant": False, "inputs": [
        {"name": "_to", "type": "address"},
        {"name": "_value", "type": "uint256"}
    ], "name": "transfer", "type": "function"}]
)

def call_with_x402(url, data, amount_usdc):
    """Make an x402 payment and call the API."""

    # Build USDC transfer (6 decimals)
    tx = usdc.functions.transfer(
        "0x7484b0bca25d2ee56e9b0535572d4cf44a047d98",
        int(amount_usdc * 10**6)
    ).build_transaction({
        "chainId": 8453,
        "gas": 65000,
        "gasPrice": w3.eth.gas_price,
        "nonce": w3.eth.get_transaction_count(account.address),
    })

    # Sign and send
    signed = account.sign_transaction(tx)
    tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash)

    # Call API with payment proof
    response = requests.post(url, data=data, headers={
        "x402-payment": receipt.transactionHash.hex()
    })
    return response.json()

# OCR a batch of documents
documents = ["invoice_1.jpg", "invoice_2.jpg", "receipt_3.jpg"]
for doc in documents:
    result = call_with_x402(
        "https://goldbean-api.xyz/paid/baidu-ocr-accurate",
        {"image": open(doc, "rb")},
        0.01  # $0.01 per call
    )
    print(f"{doc}: {result.get('words_result', [])[:3]}")

Step 4: Let AI Agents Discover Your API

If you have an API, you can turn it into an x402 storefront in minutes. Here's what you need:

A wallet on Base network with USDC
Add x402 middleware (Circle SDK or custom implementation)
Serve a /.well-known/x402-bazaar discovery endpoint

// Minimal x402 middleware for Express
import { createGatewayMiddleware } from "@circle-fin/x402-batching/server";

const gateway = createGatewayMiddleware({
  sellerAddress: "0xYOUR_WALLET",
});

app.get("/data",
  gateway.require("$0.01"),  // Price: $0.01 per call
  handler
);

That's it. Three lines and your API becomes discoverable by every x402-aware AI agent in the ecosystem.

Why x402 Matters for AI Agents

The Circle Agent Marketplace already lists 42 services with 644 endpoints. BlockRun indexes 600+ services. Every one of them is pay-per-call via x402.

This is the emerging payment standard for AI agent-to-API communication:

No signup friction: Agents don't fill out forms
No minimums: Pay $0.01 for a single call
No API key management: The wallet is the credential
Cross-platform: Works across Base, Solana, and Stripe/Tempo (MPP)

Try It Now

The easiest way to experience x402 is to make a single call to an x402-enabled API:

# Step 1: Check the price (expect 402)
curl -s -o /dev/null -w "%{http_code}" \
  "https://goldbean-api.xyz/.well-known/x402-bazaar"
# → 200 (bazaar endpoint is free)

# Step 2: Pick your stack
# - curl + Circle SDK for quick testing
# - Python + web3.py for automation
# - Node.js + x402-batching for production

GoldBean API supports x402 alongside PayPal and Alipay — one of the few marketplaces with all three payment rails. Try it at goldbean-api.xyz.

GoldBean is a pay-per-call API marketplace supporting x402 (USDC on Base), PayPal, and Alipay. Pricing starts at $0.01/call with bulk discounts available. Companion MCP server: npx goldbean-mcp.

How to Use Baidu's Unlimited OCR from Anywhere in the World (2026)

goldbean — Sat, 04 Jul 2026 04:15:06 +0000

What is Baidu Unlimited OCR?

Earlier this year, Baidu open-sourced Unlimited OCR under the MIT license — a model that can read dozens of pages of text in a single pass. It handles everything from printed Chinese invoices to handwritten English forms, all without splitting each page individually.

Sounds amazing, right? There's just one problem.

The Catch: You Need a Chinese Phone Number

To use Baidu's cloud APIs directly, you need:

A Chinese mainland phone number (实名认证 / real-name verification)
A Chinese ID or passport scan in some cases
A WeChat or Alipay account with a Chinese bank card to add funds

Just search "Baidu OCR API without Chinese phone" on any developer forum and you'll find dozens of threads. Developers from the US, Europe, and Southeast Asia all share the same frustration: the technology is world-class, but the onboarding is region-locked.

The Solution: One Curl Command, No Registration

GoldBean API bridges this gap. It gives you instant access to Baidu's full AI suite — no Chinese phone number, no real-name verification, no credit card minimums.

curl -X POST "https://goldbean-api.xyz/paid/baidu-ocr-accurate" \
  -F "image=@document.jpg"

That's it. One command, and you get back structured text from your image.

Code Example: Processing a Chinese Invoice with Fetch

const formData = new FormData();
formData.append('image', imageFile);

const response = await fetch('https://goldbean-api.xyz/paid/baidu-ocr-accurate', {
  method: 'POST',
  body: formData
});

const result = await response.json();
console.log(result.words_result);

The same pattern works for:

身份证识别 (ID card OCR)
发票识别 (invoice OCR)
通用文字识别 (general text OCR)
表格识别 (table OCR)

Beyond OCR: The Full Baidu AI Suite

GoldBean exposes Baidu's entire AI catalog without any registration friction:

Service	Endpoint	Use Case
OCR Accurate	/paid/baidu-ocr-accurate	High-accuracy text extraction
Translation	/paid/baidu-translate	200+ language pairs
TTS	/paid/baidu-tts	Text-to-speech (Chinese + English)
ASR	/paid/baidu-asr	Speech-to-text recognition
ERNIE Bot	/paid/baidu-llm-chat	Baidu's flagship LLM
Image Recognition	/paid/baidu-image-recognition	Object/scene detection
Face Detection	/paid/baidu-face-detect	Face analysis & detection
NLP	/paid/baidu-nlp	Sentiment, grammar, entity extraction

Three Payment Methods: Pick What Works for You

1. x402 (USDC micro-payments) — Each API call costs $0.01-0.08, deducted in real-time. No subscription, no minimum balance. Perfect for experimenters and small projects.

2. PayPal — Standard pay-as-you-go. Top up with your PayPal account.

3. Alipay — For users who prefer Alipay.

GoldBean is one of the few API marketplaces that supports all three payment rails simultaneously.

What You Can Build

A cross-border invoicing app that extracts Chinese invoice data automatically
A travel assistant that translates menus and signs via OCR + translation
A compliance tool that reads Chinese ID cards and passports
An accessibility tool that converts Chinese text to speech

Try It Now

# OCR a document
curl -X POST "https://goldbean-api.xyz/paid/baidu-ocr-accurate" -F "image=@test.jpg"

# Translate a phrase
curl -X POST "https://goldbean-api.xyz/paid/baidu-translate" \
  -H "Content-Type: application/json" \
  -d '{"text": "\u4f60\u597d\u4e16\u754c", "from": "zh", "to": "en"}'

No signup. No Chinese phone number. Just your API key and a payment method.

GoldBean API is a pay-per-use AI API marketplace. Prices range from $0.01 to $0.08 per call depending on the service. Visit goldbean-api.xyz for the full catalog.

How to Use Baidu Unlimited OCR from Anywhere in the World (2026)

goldbean — Sat, 04 Jul 2026 04:10:50 +0000

How to Use Baidu Unlimited OCR from Anywhere in the World (2026)

Last week, Baidu open-sourced Unlimited-OCR under the MIT license — a model that can transcribe dozens of pages in a single forward pass, using a novel "glance attention" mechanism inspired by how humans copy documents.

This is exciting for document digitization and form processing. But there's a catch many international developers don't realize: registering for Baidu AI APIs from outside China is a real obstacle.

The Pain Point

To use Baidu's OCR through their official API, you need:

A Chinese phone number for SMS verification
Real-name authentication (身份证实名认证)
A Chinese bank card or Alipay account for deposits
Minimum pre-payment of ¥100+ (+) before your first call

If you're a developer in the US, Europe, or Southeast Asia — or really anywhere without a 中国手机号 — this is a showstopper. Even with a VPN, the Baidu AI platform requires Chinese ID for paid tiers.

What Baidu Unlimited-OCR Actually Is

Unlimited-OCR is an open-source model (MIT license) that processes entire multi-page documents in one pass. It achieves 96%+ accuracy on Chinese text using a transformer architecture with a "glance attention" mechanism — the model maintains a context of previously transcribed regions so it doesn't re-scan everything on each page.

Key specs:

Processes dozens of document pages in one forward pass
MIT licensed — fully open source
96%+ accuracy on Chinese printed text
Supports English, Japanese, and mixed-language documents

The model weights are on GitHub, but running it yourself requires significant GPU resources. Many developers prefer an API-based approach.

The Workaround: GoldBean

GoldBean is a pay-per-use API marketplace that wraps Baidu's AI APIs behind a simple REST interface. The key differentiator: you don't need a Chinese phone number or ID to use it.

Try it with curl:

ash curl -X POST https://goldbean-api.xyz/paid/baidu-ocr \ -H "Content-Type: application/json" \ -H "x-api-key: YOUR_KEY" \ -d '{"image": "https://example.com/doc.jpg"}'

In Python:

python import requests resp = requests.post( "https://goldbean-api.xyz/paid/baidu-ocr", json={"image": "https://example.com/doc.jpg"}, headers={"x-api-key": "YOUR_KEY"} ) print(resp.json()["words_result"])

Pricing vs Baidu Direct

Feature	Baidu Direct	GoldBean
Registration	Chinese phone + ID	Email only
Min deposit	¥100 ()	(free tier)
Per call	¥0.02-0.05	.01-0.02
Payment	Alipay/WeChat (CN only)	USDC, PayPal, Alipay
Free tier	None	50 calls/day
Global	China VPN often needed	Works worldwide

Beyond OCR

GoldBean also offers Baidu Translation, TTS, NLP, Face Detection, and PaddleOCR-VL — all through the same no-hassle registration. 120+ endpoints in total.

Try it: goldbean-api.xyz — no phone number, no ID, no deposit. 50 free calls/day.

Have you tried Baidu's Unlimited-OCR? Drop your experience below.

GoldBean (GB) — Wishing You Good Fortune & Prosperity 🫘

GoldBean OCR + Translation Pipeline: Processing Chinese Documents in 10 Lines of Python

goldbean — Sun, 28 Jun 2026 10:15:51 +0000

Ever struggled with Chinese document processing? Between expensive services and complex SDKs, it's a pain. Let me show you how GoldBean API handles this in 10 lines of Python.

What You'll Need

A GoldBean API key (free tier: 1000 requests/month)
Python 3.7+
An image URL or local file with Chinese text

Step 1: OCR (Extract Chinese Text)

import requests

API_BASE = "https://goldbean-api.xyz/paid"
API_KEY = "your-key-here"  # Get yours at https://goldbean-api.xyz

# OCR an image with Chinese text
image_url = "https://example.com/chinese-doc.jpg"
ocr_resp = requests.post(f"{API_BASE}/ocr", json={
    "image_url": image_url,
    "api_key": API_KEY
}).json()

chinese_text = ocr_resp.get("text", "")
print(f"Extracted: {chinese_text[:200]}...")

Step 2: Translate (Chinese → English)

# Translate the extracted Chinese text
translation = requests.post(f"{API_BASE}/translate", json={
    "text": chinese_text,
    "source": "zh",
    "target": "en",
    "api_key": API_KEY
}).json()

english_text = translation.get("translated_text", "")
print(f"Translated: {english_text[:200]}...")

Step 3: TTS (Read It Aloud)

# Convert Chinese text to speech
tts = requests.post(f"{API_BASE}/tts", json={
    "text": chinese_text,
    "voice": "baidu-zh",
    "api_key": API_KEY
}).json()

print(f"Audio URL: {tts.get('audio_url')}")

Full Pipeline in One Script

import requests

def process_chinese_doc(image_url, api_key):
    base = "https://goldbean-api.xyz/paid"
    headers = {"Content-Type": "application/json"}

    # OCR
    ocr = requests.post(f"{base}/ocr", json={"image_url": image_url, "api_key": api_key}).json()
    text = ocr.get("text", "")

    # Translate
    trans = requests.post(f"{base}/translate", json={"text": text, "source": "zh", "target": "en", "api_key": api_key}).json()

    # Analyze sentiment
    sentiment = requests.post(f"{base}/sentiment", json={"text": text, "api_key": api_key}).json()

    return {
        "original_text": text[:500],
        "translation": trans.get("translated_text", ""),
        "sentiment": sentiment.get("sentiment", "unknown")
    }

# Try it with a sample
result = process_chinese_doc("https://i.imgur.com/sample-chinese-doc.jpg", "YOUR_API_KEY")
print(json.dumps(result, indent=2, ensure_ascii=False))

Why GoldBean?

Feature	GoldBean	Baidu Direct
Pricing	$0.01/call	$100 deposit + usage
Payment	Pay-as-you-go	Prepaid account
Setup	API key only	SDK + auth
Free tier	1000 req/month	None

Try it: https://goldbean-api.xyz/docs

GoldBean — $0.01 per call, no monthly fees, no deposits. 120+ endpoints in 26 categories.

💡 Have you tried GoldBean? Get 50 free API calls/day at goldbean-api.xyz — no credit card needed. Questions? Drop a comment below!

🫘 GoldBean — Pay-per-Use AI API Marketplace. Wishing You Good Fortune & Prosperity.

AI Agent 自动化交易

goldbean — Sun, 21 Jun 2026 06:26:11 +0000

AI Agent 自动化交易：用 GoldBean MCP + x402 搭建零人力交易机器人 🤖💰

痛点

手动盯盘、手动下单、手动结算 — 交易员每天 80% 的时间花在重复操作上。

如果 Agent 能自动监控价格、自动搜索新闻、自动执行交易呢？

这就是 GoldBean MCP 要解决的问题。

什么是 GoldBean MCP？

GoldBean MCP Server 提供 10 个生产级 AI API，专为 autonomous agents 设计：

| 工具 | 用途 | 调用费用 |

|

💡 Have you tried GoldBean? Get 50 free API calls/day at goldbean-api.xyz — no credit card needed. Questions? Drop a comment below!

🫘 GoldBean — Pay-per-Use AI API Marketplace. Wishing You Good Fortune & Prosperity.

GoldBean Just Got Listed in public-apis (39.8k⭐) & awesome-mcp-servers — Here's How

goldbean — Sat, 20 Jun 2026 09:37:50 +0000

I launched GoldBean — an x402 micropaid API marketplace — a few weeks ago. Today, it's been listed in two of the largest GitHub curated lists:

✅ public-apis/public-apis (39,800+ stars)
✅ punkpeye/awesome-mcp-servers
⏳ MCPize — onboarding in progress

Here's the play-by-play of how each listing happened and what I learned.

📍 public-apis — The Big One

What It Is

The most-starred API directory on GitHub (39.8k⭐). If your API is here, thousands of developers will discover it.

How It Happened

@dajiaohuang, a researcher from NUS Singapore, discovered GoldBean and volunteered to submit a PR (#6357). He saw the value in the x402 pay-per-call model and took the initiative.

Within a few days, the PR was merged and GoldBean appeared in the README.

Lesson Learned

Build something genuinely useful, and the community will promote it for you.

This wasn't a cold email or spam. Someone found the API, liked it, and submitted it. The best listing strategy is a product that solves a real problem.

📍 awesome-mcp-servers — The MCP Gateway

What It Is

The go-to directory for MCP servers — tools that AI Agents (Claude, Cursor, Cline, etc.) can use directly.

How It Happened

The first PR I submitted (#7439) is still open. But someone else submitted PR #8212 independently, and the repo maintainer punkpeye merged it after confirming:

"Added the Glama score badge — your server passes all checks."

This is now visible in the README with a Glama score badge.

Lesson Learned

When your product is discoverable, you don't control who submits it to which directory — and that's a good sign.

Having multiple independent submissions is stronger than a single curated PR.

📍 MCPize — The Platform Native to x402

What It Is

A marketplace where MCP servers are listed and can charge by usage — the perfect fit for x402 micropaid APIs.

Current Status

MCPize is processing our listing. The emails have arrived:

✅ Welcome email
✅ Quality check passed ("1 thing to improve" flagged)
✅ Getting started guide

This one is still in progress but shows promise.

🛠 What I Did for the Listings

Actually, very little:

Built a working product — 120+ API endpoints, pay-per-call via x402
Made it easy to discover — npx goldbean-mcp installs in 1 command
Submitted PRs — A few manual PRs to relevant directories
The rest happened organically — someone else found it and submitted it

📊 Current Status Board

Directory	Status	Stars
public-apis	✅ Listed	39.8k⭐
awesome-mcp-servers	✅ Listed	—
MCPize	⏳ Onboarding	—
awesome-agentic-commerce #301	⏳ Open PR	—
Awesome-MCP-ZH #297	⏳ Open PR	—
awesome-ocr #150	⏳ Open PR	—
awesome-x402-mcp-services #20	⏳ Open PR	—

🏆 What This Means for GoldBean Users

✅ Social proof — 39.8k⭐ repo vetted this API
✅ Glama score badge — automated quality check passed
✅ More discovery — developers browsing these lists will find GoldBean
✅ Free daily tier — still offering 50 free calls/day, no wallet needed

🫘 Try GoldBean

npx goldbean-mcp

No signup. No API key. Just install and ask your AI agent to use it.

GoldBean (GB) — Wishing You Good Fortune & Prosperity 🫘 祝您吉祥如意

💡 Have you tried GoldBean? Get 50 free API calls/day at goldbean-api.xyz — no credit card needed. Questions? Drop a comment below!

🫘 GoldBean — Pay-per-Use AI API Marketplace. Wishing You Good Fortune & Prosperity.

GoldBean Just Landed on MCPize + Stripe — 146 APIs, Pay-Per-Call, No Monthly Fees

goldbean — Fri, 19 Jun 2026 00:51:59 +0000

🚀 GoldBean on MCPize: The Backstory

Yesterday I successfully deployed GoldBean API on MCPize, the new MCP server marketplace. Combined with Stripe Connect for payouts, this makes GoldBean one of the most complete x402 API marketplaces out there.

What Changed

MCPize Marketplace — GoldBean is now listed at mcpize.com/mcp/goldbean with auto-generated MCP server (goldbean.mcpize.run)
Stripe Connect — Integrated for developer payouts, 146 API routes auto-discovered
Free Tier — 1,000 calls/month free, then pay-per-call from $0.01

The Full Stack

Layer	Tech
APIs	Baidu OCR, NLP, TTS, ASR, Translation, ERNIE LLM + 140 more
Payment	x402 (HTTP 402) + Stripe + Alipay + PayPal
Discovery	MCPize, Smithery.ai, Glama.ai
Gateway	goldbean.mcpize.run (edge functions)

Why This Matters for MCP

The MCP ecosystem has a monetization problem. Everyone builds MCP servers, but nobody pays for them. GoldBean solves this with:

x402 micropayments — HTTP 402 response prompts the client to pay $0.01 automatically
No API key registration — Just send an x-user-id header with your wallet address
USDC on Base — 2-second settlement, no gas fees for the caller

Try It

Browse APIs: goldbean-api.xyz/debug
MCPize listing: mcpize.com/mcp/goldbean
Pricing: free tier (5 endpoints) + basic ($0.01/call) + standard ($0.02/call)

Happy building! 🫘

💡 Have you tried GoldBean? Get 50 free API calls/day at goldbean-api.xyz — no credit card needed. Questions? Drop a comment below!

🫘 GoldBean — Pay-per-Use AI API Marketplace. Wishing You Good Fortune & Prosperity.

The Cheapest Chinese OCR API in the World — $0.01 per Call, Built on x402

goldbean — Thu, 18 Jun 2026 06:54:45 +0000

The Cheapest Chinese OCR API in the World — $0.01 per Call, Built on x402

Chinese OCR is dramatically harder than English OCR. While English has only 26 characters, Chinese has over 50,000 characters in the Unicode set — with thousands in common daily use. Many characters look nearly identical, differing by a single stroke. This complexity means most OCR providers charge premium rates for Chinese recognition, often $0.10-$0.50 per 1,000 calls, or require hefty monthly subscriptions that lock you into long-term commitments.

GoldBean API flips this model entirely. It offers Chinese OCR at just $0.01 per call, no subscription required, pay-per-use via the x402 protocol. That's right — one cent per image, powered by one of the best Chinese OCR engines available, delivered through a modern payment protocol that AI agents can use autonomously.

The Tech Stack

Backend: Node.js / Express running on Cloudflare Workers for global low-latency access
OCR Engine: Baidu OCR — widely recognized as best-in-class for Chinese character recognition, supporting printed text, handwriting, and document layouts
Payment: x402 protocol (HTTP 402 + USDC on Base) — each API call triggers an instant micro-transaction
Free Tier: 20 free credits for testing — pay nothing to try it out
Live Demo: https://wuzenghai616-lang.github.io/goldbean/

Why x402 Changes Everything

Traditional API monetization requires you to enter a credit card, commit to a monthly plan, and hope you don't exceed your quota. The x402 protocol turns this on its head:

AI agents can pay autonomously — no human credit card required. An AI agent calls the API, receives an HTTP 402 response with payment instructions, settles the micro-transaction in seconds, and gets the result.
Settlement in seconds — USDC on Base means near-instant settlement, no waiting for bank transfers or credit card holds.
No subscription lock-in — pay exactly for what you use. One call, one cent. No monthly minimums, no annual contracts.
Transparent pricing — the cost is fixed and known upfront. $0.01 per OCR call, always.

Code Example

Calling the OCR endpoint is straightforward with any HTTP client:

// Call OCR with just an API key
const response = await fetch('https://goldbean-api.xyz/paid/baidu-ocr', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-user-id': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    image: imageBase64
  })
});

const data = await response.json();
console.log(data.words_result);

The API accepts base64-encoded images and returns JSON with recognized text, positions, and confidence scores. It's that simple.

Getting Started

Register at https://goldbean-api.xyz/paid/user/register to get your free credits
Try the live OCR demo: https://wuzenghai616-lang.github.io/goldbean/ — upload an image and see the results instantly
Browse all 146+ endpoints at https://mcpize.com/mcp/goldbean — GoldBean isn't just OCR; it's a whole marketplace of AI APIs priced at $0.01-$0.05 per call

Call to Action

Try it free today. No credit card, no commitment. If you're building an AI agent that needs to process Chinese text, or you're just tired of subscription-based API pricing, GoldBean's x402-powered OCR is the most affordable option available.

Build with it. Pay only when you scale.

This is Article #2 in the "Monetizing AI APIs with x402" series. Check out the series for more deep dives into autonomous AI payments and micro-transaction APIs.

💡 Have you tried GoldBean? Get 50 free API calls/day at goldbean-api.xyz — no credit card needed. Questions? Drop a comment below!

🫘 GoldBean — Pay-per-Use AI API Marketplace. Wishing You Good Fortune & Prosperity.