DEV Community: Yaqing2023

MoltsPay: The Most Comprehensive Payment Layer for AI Agents

Yaqing2023 — Thu, 16 Apr 2026 07:24:30 +0000

MoltsPay: The Most Comprehensive Payment Layer for AI Agents

AI agents need to pay for things. Whether it's generating a video, writing code, or accessing premium APIs, the agentic economy requires a payment infrastructure that works everywhere.

Today, I'm excited to announce that MoltsPay is now available across three major platforms, making it the most comprehensive payment solution for AI agents:

Model Context Protocol (MCP) - Standardized integration for ChatGPT, Claude, and MCP-compatible AI assistants
Node.js (npm) - Full-featured SDK for JavaScript/TypeScript environments
Python - Native SDK for Python-based agents and applications

What is MoltsPay?

MoltsPay is blockchain payment infrastructure designed specifically for AI agents. It enables autonomous, gasless crypto payments using the x402 protocol on multiple chains (Base, Polygon, BNB, Tempo, Solana, and more).

Core Features

Gasless Payments

No ETH or gas tokens required for users
Facilitator handles all on-chain execution
Client only signs transactions using USDC

Multi-Chain Support

Base (EVM)
Polygon (EVM)
BNB Chain (EVM)
Tempo Moderato (MPP protocol)
Solana (Solana PFS)

Agent-to-Agent Commerce

Services publish pricing via .well-known/agent-services.json
Agents discover, price, and pay automatically
Fully autonomous transactions without human intervention

Three Ways to Integrate MoltsPay

1. Model Context Protocol (MCP)

Best for: ChatGPT, Claude, and AI assistants supporting MCP

MoltsPay is now available as an MCP server, enabling any MCP-compatible AI assistant to access payment functionality through the open MCP standard.

# Add MoltsPay MCP to your MCP client configuration
{
  "mcpServers": {
    "moltspay": {
      "command": "npx",
      "args": ["-y", "moltspay-mcp-server"]
    }
  }
}

Available MCP Tools:

search_services(query) - Discover AI services that accept MoltsPay
get_service(id) - Get service details and pricing
pay_service(service_id, params) - Execute gasless payments
get_wallet_status() - Check wallet balance and status

Example usage in ChatGPT:

User: Generate a video of a dragon flying over mountains

→ MCP discovers Zen7 video service ($0.99 USDC)
→ Shows pricing and asks for confirmation
→ Executes x402 payment (gasless)
→ Returns the generated video

All wallet operations happen client-side. The AI assistant never holds your private keys.

Why MCP matters:
MCP creates a standardized way for AI models to connect to external tools. Think of it as USB for AI. By exposing MoltsPay through MCP, we enable any MCP-compatible AI assistant to participate in the agentic economy without custom integrations.

GitHub: https://github.com/Yaqing2023/moltspay-chatgpt-app

2. Node.js / npm

Best for: Custom agents, web applications, and Node.js environments

The MoltsPay npm package provides a complete SDK for JavaScript and TypeScript developers.

npm install moltspay

Quick Start:

import { PaymentAgent } from 'moltspay';

// Initialize your agent's wallet
const agent = new PaymentAgent({
  chain: 'base',
  privateKey: process.env.AGENT_PRIVATE_KEY
});

// Discover and pay for a service
const service = await agent.discoverService('https://juai8.com/zen7');
console.log(`Service: ${service.name}, Price: $${service.price}`);

// Execute payment
const result = await agent.pay(service, {
  prompt: 'a cat dancing in the rain'
});

console.log('Payment successful:', result.txHash);
console.log('Service result:', result.output);

Features:

Automatic service discovery from .well-known/agent-services.json
Multi-chain wallet management (one private key per chain family)
x402 signing and payment execution
Transaction verification and receipt handling
Built-in error handling and retry logic

CLI Tool:

For quick testing and manual operations:

npm install -g moltspay

# Initialize wallet
npx moltspay init --chain base

# Check status
npx moltspay status

# Pay for a service
npx moltspay pay https://juai8.com/zen7 text-to-video \
  --prompt "a dragon flying over mountains"

npm: https://www.npmjs.com/package/moltspay

GitHub: https://github.com/Yaqing2023/moltspay

3. Python SDK

Best for: Python-based agents, data science workflows, and backend services

The MoltsPay Python SDK brings the same functionality to the Python ecosystem.

pip install moltspay-python

Quick Start:

from moltspay import PaymentAgent
import os

# Initialize your agent's wallet
agent = PaymentAgent(
    chain='base',
    private_key=os.environ['AGENT_PRIVATE_KEY']
)

# Discover and pay for a service
service = agent.discover_service('https://juai8.com/zen7')
print(f"Service: {service.name}, Price: ${service.price}")

# Execute payment
result = agent.pay(
    service=service,
    params={'prompt': 'a cat dancing in the rain'}
)

print(f"Payment successful: {result.tx_hash}")
print(f"Service result: {result.output}")

Features:

Type-safe API with full IDE support
Async/await support for concurrent operations
Multi-chain wallet management
Server-side facilitator for pay-for-success flows
Comprehensive error handling

PyPI: https://pypi.org/project/moltspay-python/

GitHub: https://github.com/Yaqing2023/moltspay-python

Architecture: How It Works

MoltsPay uses the x402 protocol for gasless payments. Here's the flow:

┌─────────────┐     ┌──────────────────┐     ┌─────────────────┐
│   AI Agent  │────▶│   MoltsPay SDK  │────▶│  Service API    │
│  (Payer)    │     │   (Client)       │     │  (Provider)     │
└─────────────┘     └──────────────────┘     └─────────────────┘
                           │                        │
                           ▼                        ▼
                    ┌──────────────┐         ┌──────────────┐
                    │   Wallet     │         │  x402        │
                    │  (Client)    │────────▶│  Protocol    │
                    └──────────────┘         └──────────────┘
                                                   │
                                                   ▼
                                            ┌──────────────┐
                                            │  Facilitator │
                                            │  (CDP/Others)│
                                            └──────────────┘

Agent discovers service via .well-known/agent-services.json
SDK generates x402 payment intent with EIP-3009/EIP-2612 signing
Client signs transaction using USDC (no gas needed)
Facilitator executes on-chain using CDP or other providers
Service verifies payment and delivers results

UPP: Universal Payment Protocol

Under the hood, MoltsPay uses UPP (Universal Payment Protocol) to abstract away chain differences:

Chain	Protocol	Facilitator
Base, Polygon	x402 (EIP-3009)	CDP
BNB	BNB Pre-Approval (EIP-712)	Pay-for-success
Tempo	MPP (Machine Payments Protocol)	Direct verification
Solana	Solana PFS	Pay-for-success

Developers don't need to worry about these details—UPP selects the correct protocol automatically.

Creating a MoltsPay-Powered Service

Adding MoltsPay to any AI service takes 5 minutes:

1. Create your service definition

{
  "provider": {
    "name": "My AI Service",
    "wallet": "0xb8d6f2441e8f8dfB6288A74Cf73804cDd0484E0C"
  },
  "services": [{
    "id": "my-service",
    "function": "generate",
    "price": 0.99,
    "currency": "USDC"
  }]
}

2. Expose it via `.well-known`

# Place at: https://your-service.com/.well-known/agent-services.json

3. Handle x402 payments

// Node.js example using moltspay-python server
import { PaymentServer } from 'moltspay-python';

const server = new PaymentServer({
  providerWallet: '0xb8d6f2441e8f8dfB6288A74Cf73804cDd0484E0C',
  chains: ['base', 'polygon']
});

// Register your service handler
server.registerService('my-service', async (payment, params) => {
  // Verify payment is confirmed
  if (payment.verified) {
    // Execute your AI service
    const result = await myAIService(params);
    return result;
  }
});

4. Register in the directory

Visit https://moltspay.com/directory to list your service.

Real-World Examples

Zen7: AI Video Generation

The first MoltsPay-powered service, accepting autonomous payments:

Text-to-Video: $0.99 USDC
Image-to-Video: $1.49 USDC
Network: Base (gasless via x402)

Try it:

npx moltspay pay https://juai8.com/zen7 text-to-video \
  --prompt "a dragon flying over mountains"

More Services

Discover more MoltsPay-powered services at:

Why MoltsPay Matters

1. Standardization

Before MoltsPay, every AI agent payment integration was custom. Now we have:

MCP for AI assistants
npm for Node.js environments
Python for Python ecosystems
UPP for cross-chain abstraction

2. Gasless for Users

Users don't need ETH or gas tokens. They only need USDC, which they already have.

3. Agent Autonomy

Agents can discover, price, and pay for services without human intervention. This is essential for the agentic economy.

4. Multi-Chain Flexibility

Deploy on Base, Polygon, BNB, Tempo, or Solana—MoltsPay handles the protocol differences automatically.

5. Open Source

All SDKs and tools are open source. No vendor lock-in.

Getting Started

Choose your platform:

MCP Users

# Add to your MCP client config
{
  "mcpServers": {
    "moltspay": {
      "command": "npx",
      "args": ["-y", "moltspay-mcp-server"]
    }
  }
}

Node.js Developers

npm install moltspay

Python Developers

pip install moltspay-python

Documentation: https://moltspay.com/docs

GitHub:

Main SDK: https://github.com/Yaqing2023/moltspay
Python SDK: https://github.com/Yaqing2023/moltspay-python
MCP Server: https://github.com/Yaqing2023/moltspay-chatgpt-app

The Future of Agentic Commerce

We're building the payment infrastructure for the agentic economy. As AI agents become more autonomous, they need reliable, standardized ways to transact.

MoltsPay is that infrastructure.

Join us in building the open payment layer for AI agents.

This is not financial advice. Always do your own research before using blockchain-based services.

🎉 @moltspay/plugin-elizaos - Crypto Payments for ElizaOS Bots

Yaqing2023 — Sat, 28 Mar 2026 16:21:30 +0000

Just published @moltspay/plugin-elizaos on npm — now any ElizaOS bot can pay for services with crypto.

What It Does

💳 Gasless Payments — Pay with USDC, no ETH needed
🔍 Service Discovery — Browse MoltsPay marketplace
🌐 Multi-chain — Base, Polygon, Base Sepolia (testnet)
🔐 Spending Limits — Built-in per-tx and daily limits
🇨🇳 Bilingual — English and Chinese support

Install

cd /path/to/your/eliza-project
npm install @moltspay/plugin-elizaos

Add to your character config:

plugins: [
  "@elizaos/plugin-sql",
  "@moltspay/plugin-elizaos",
],

Usage

Once installed, your bot can:

Initialize my MoltsPay wallet — Create a wallet
Check my balance — View USDC balance
What services can I buy? — Browse marketplace
Pay for Text to Video, a cat dancing — Purchase services

Payment is gasless via x402 protocol. Your bot signs, we execute. Pay only on success.

MoltsPay Python SDK 0.7.0: Multi-Chain Agent Payments Are Here

Yaqing2023 — Mon, 23 Mar 2026 23:03:13 +0000

TL;DR

MoltsPay Python SDK now supports 8 blockchain networks for AI agent payments. Pay for services on Base, Polygon, BNB, Solana, and more — all gasless.

pip install moltspay==0.7.0

What's MoltsPay?

MoltsPay is payment infrastructure for AI agents. It lets agents pay for services (video generation, image processing, API calls) using stablecoins — without needing gas tokens or complex wallet management.

The protocol uses x402 for gasless payments: client signs an intent, server settles on-chain.

What's New in 0.7.0

8 Supported Chains

Chain	Network ID	Tokens
Base	`base`	USDC, USDT
Polygon	`polygon`	USDC
BNB Chain	`bnb`	USDC, USDT
opBNB	`opbnb`	USDC
Solana	`solana`	USDC
Tempo	`tempo_moderato`	pathUSD
Base Sepolia	`base_sepolia`	USDC
BNB Testnet	`bnb_testnet`	USDC

Multi-Chain Server

The Python server now handles payments from ANY supported chain automatically:

from moltspay.server import create_server

app = create_server(
    skill_dir='./my-skill',
    networks=['base', 'polygon', 'bnb', 'solana'],  # Accept all!
    wallet='0x...',
    solana_wallet='So1ana...'
)

The server detects which chain the client wants to pay on and routes to the correct facilitator.

Solana Support

Solana uses a separate Ed25519 keypair (not EVM). The SDK handles this automatically:

# Initialize creates both EVM + Solana wallets
moltspay init

# Check balances on all chains
moltspay status

Quick Start: Client

# Install
pip install moltspay

# Create wallet
moltspay init

# Fund with testnet USDC
moltspay faucet --chain base_sepolia

# Pay for a service
moltspay pay https://example.com/api text-to-video \
  --prompt "a cat dancing" \
  --chain base_sepolia

Quick Start: Server

Create a paid AI service in 3 files:

moltspay.services.json

{
  "provider": {
    "name": "My AI Service",
    "wallet": "0xYourWallet"
  },
  "services": [{
    "id": "generate-image",
    "name": "AI Image Generation",
    "function": "generate",
    "price": 0.50,
    "currency": "USDC",
    "networks": ["base", "polygon", "bnb"]
  }]
}

index.py

async def generate(prompt: str) -> dict:
    # Your AI logic here
    image_url = await my_ai_model(prompt)
    return {"image": image_url}

Run it:

moltspay start ./my-skill --port 8402

That's it. Your service now accepts gasless USDC payments on 3 chains.

For AI Agent Developers

We also updated the MoltsPay Skill for agent frameworks:

# OpenClaw / LangChain agents can install:
npm install moltspay-skill

The skill teaches agents how to:

Initialize wallets
Check balances across chains
Discover and pay for services
Handle errors gracefully

Why Multi-Chain?

Different chains have different tradeoffs:

Base: Lowest fees, Coinbase ecosystem
Polygon: Widely supported, good liquidity
BNB: High liquidity in Asia
Solana: Fastest confirmations
opBNB: Ultra-low fees for micro-payments

Letting your service accept multiple chains means more potential customers.

MoltsPay Now Supports Solana and BNB: Gasless Payments Across 5 Blockchains

Yaqing2023 — Sun, 22 Mar 2026 21:40:26 +0000

MoltsPay Now Supports Solana and BNB: Gasless Payments Across 5 Blockchains

TL;DR: MoltsPay v1.3.0 adds Solana and BNB chain support with gasless payments. AI agents can now pay for services on Base, Polygon, Solana, BNB, and Tempo - all without paying gas fees.

The Problem We're Solving

As AI agents become more autonomous, they need to pay for external services - APIs, compute, data, and other AI agents' services. But blockchain payments have a major UX problem: gas fees.

Every transaction requires:

The right native token (ETH, SOL, BNB) for gas
Enough balance to cover unpredictable fees
Complex wallet management across chains

For AI agents operating autonomously, this is a nightmare. An agent shouldn't need to worry about having 0.001 BNB for gas when it just wants to pay $0.99 for a video generation service.

Our Solution: Self-Hosted Facilitators

With MoltsPay v1.3.0, we've introduced self-hosted facilitators for Solana and BNB chains. Here's what that means:

How It Works

┌─────────┐         ┌─────────┐         ┌──────────┐
│  Client │         │  Server │         │ Blockchain│
│ (Agent) │         │(Service)│         │          │
└────┬────┘         └────┬────┘         └────┬─────┘
     │                   │                   │
     │ Request service   │                   │
     │──────────────────>│                   │
     │                   │                   │
     │ 402 + pay details │                   │
     │<──────────────────│                   │
     │                   │                   │
     │ Sign payment      │                   │
     │ (NO GAS!)         │                   │
     │──────────────────>│                   │
     │                   │                   │
     │                   │ Execute payment   │
     │                   │ (server pays gas) │
     │                   │──────────────────>│
     │                   │                   │
     │ Service result    │                   │
     │<──────────────────│                   │

The key insight: Clients only sign payment authorizations - they never pay gas. The server (acting as a facilitator) handles on-chain execution and absorbs the minimal gas cost (~$0.001 per transaction).

Two Types of Facilitators

MoltsPay now supports two facilitator architectures:

Type	Example	Who Pays Gas	Trust Model
External	Coinbase CDP	Third party	Trust Coinbase
Self-hosted	SOL, BNB, Tempo	Your server	Fully self-sovereign

Why Self-Hosted Matters

No Single Point of Failure - Unlike CDP where everyone depends on Coinbase, each service provider runs their own facilitator.
Censorship Resistant - No third party can block your payments.
Chain Agnostic - We can add any blockchain by implementing a facilitator. No need to wait for third-party support.
Cost Control - You only pay actual on-chain gas (~$0.001), not third-party fees.

Supported Chains

Chain	Facilitator	Gas Model
Base	CDP (External)	Gasless (CDP pays)
Polygon	CDP (External)	Gasless (CDP pays)
Solana	Self-hosted	Gasless (server pays ~$0.001)
BNB	Self-hosted	Gasless (server pays ~$0.0001)
Tempo	Self-hosted	Native gas-free

Quick Start

For AI Agents (Paying for Services)

# Install
npm install moltspay

# Initialize wallet (creates both EVM and Solana wallets)
npx moltspay init

# Get testnet tokens
npx moltspay faucet --chain bnb_testnet    # BNB testnet
npx moltspay faucet --chain solana_devnet  # Solana devnet

# Pay for a service on BNB
npx moltspay pay https://moltspay.com/a/zen7 text-to-video \
  --chain bnb_testnet \
  --prompt "a cat dancing"

# Pay on Solana
npx moltspay pay https://moltspay.com/a/zen7 text-to-video \
  --chain solana_devnet \
  --prompt "a robot painting"

For Service Providers (Accepting Payments)

Add one JSON file to your existing skill:

{
  "provider": {
    "name": "My AI Service",
    "wallet": "0xYourEVMAddress",
    "solana_wallet": "YourSolanaAddress",
    "chains": ["base", "solana", "bnb"]
  },
  "services": [{
    "id": "my-service",
    "function": "myFunction",
    "price": 0.99,
    "currency": "USDC"
  }]
}

Start your server:

npx moltspay start ./my-skill --port 3000

That's it! Your service now accepts gasless payments on 5 chains.

The Technical Details

Solana Implementation

Solana required a completely different approach since it's not an EVM chain:

Separate wallet - Ed25519 keys (different from EVM's secp256k1)
SPL Token transfers - Official Circle USDC
Server as fee payer - Client signs, server executes

// Client signs SPL transfer authorization
const signature = await wallet.signTransaction(transferTx);

// Server adds itself as fee payer and submits
transaction.feePayer = serverPublicKey;
await connection.sendTransaction(transaction);

BNB Implementation

BNB uses an EIP-712 intent-based flow:

// Client signs EIP-712 payment intent (gasless)
const signature = await wallet.signTypedData(domain, types, intent);

// Server executes transferFrom (pays ~$0.0001 gas)
await usdc.transferFrom(client, server, amount);

The key innovation: pay-for-success. Payment only settles if the service succeeds. If the service fails, the client keeps their money.

What's Next

We're working on:

More chains - Arbitrum, Optimism, Sui, Aptos
Cross-chain payments - Pay on Chain A, receive on Chain B
Decentralized facilitator network - On-chain facilitator contracts with staking

Try It Now

npm: npm install moltspay
GitHub: github.com/Yaqing2023/moltspay
Docs: moltspay.com
Discord: Join our community

About MoltsPay

MoltsPay is open-source payment infrastructure for AI agents. We implement the x402 protocol - HTTP-native payments where AI agents can pay each other for services without human intervention.

Star us on GitHub if you find this useful! ⭐

Have questions? Drop by our Discord or open an issue on GitHub.

Tags: #ai #blockchain #solana #bnb #payments #web3 #opensource #cryptocurrency

MoltsPay 1.3.0: Now with Tempo Testnet & MPP Protocol Support

Yaqing2023 — Fri, 20 Mar 2026 04:10:32 +0000

MoltsPay 1.3.0: Now with Tempo Testnet & MPP Protocol Support

We just shipped MoltsPay 1.3.0 with support for the Tempo Moderato testnet and the Machine Payments Protocol (MPP) — making it even easier for AI agents to pay each other.

What's New

🎵 Tempo Testnet Support

Tempo is a gas-free blockchain designed for machine-to-machine payments. With MoltsPay 1.3.0, you can now test agent payments without spending real money or worrying about gas fees.

# Get free testnet tokens
npx moltspay faucet --chain tempo_moderato

# Pay on Tempo (completely gas-free!)
npx moltspay pay https://juai8.com/zen7 text-to-video \
  --prompt "a robot dancing" \
  --chain tempo_moderato

Tempo Stablecoins:

pathUSD (USDC equivalent)
alphaUSD (USDT equivalent)

🤖 MPP Protocol Support

MPP (Machine Payments Protocol) is an alternative to x402 that's simpler for gas-free chains like Tempo:

Client                         Server
  │ POST /service                │
  │ ─────────────────────────>   │
  │ 402 + WWW-Authenticate       │
  │ <─────────────────────────   │
  │ [Execute transfer on Tempo]  │
  │ POST + Authorization: Payment│
  │ ─────────────────────────>   │
  │ 200 OK + result              │
  │ <─────────────────────────   │

The client executes the payment directly on-chain, then retries with the transaction hash. No intermediary needed.

🔍 Service Discovery

New CLI options for finding services:

# Search by keyword
npx moltspay services -q "video"

# Filter by price
npx moltspay services --max-price 1.00

# Filter by type
npx moltspay services --type api_service

# Filter by tag
npx moltspay services --tag ai

Protocol Comparison

Protocol	Chains	Gas	How it works
x402	Base, Polygon	Gasless (CDP pays)	Client signs, facilitator executes
MPP	Tempo	Native gas-free	Client executes directly

Both protocols use HTTP 402 Payment Required — the difference is who submits the transaction.

Quick Start

1. Install:

npm install moltspay@latest

2. Initialize wallet:

npx moltspay init

3. Get testnet tokens:

# Option A: Base Sepolia (x402)
npx moltspay faucet

# Option B: Tempo Moderato (MPP)
npx moltspay faucet --chain tempo_moderato

4. Test a payment:

npx moltspay pay https://juai8.com/zen7 text-to-video \
  --prompt "a man dancing in the rain" \
  --chain tempo_moderato

For Service Providers

Add Tempo support to your existing service with one line:

{
  "provider": {
    "wallet": "0x...",
    "chains": ["base", "tempo_moderato"]
  }
}

MoltsPay server automatically handles both x402 and MPP protocols on the same endpoint.

What's Next

More testnet integrations
Registry UI improvements
Python SDK update with MPP support

Introducing MoltsPay Plugin for ElizaOS — Give Your AI Agent a Wallet 💳

Yaqing2023 — Thu, 19 Mar 2026 00:55:59 +0000

What if your AI agent could pay for services on its own? Not through your credit card, not via API keys with usage limits — but with its own wallet, its own spending limits, and complete autonomy.

Today we're releasing moltspay-eliza-plugin, a plugin that brings gasless crypto payments to ElizaOS agents.

What is ElizaOS?

ElizaOS is an open-source framework for building autonomous AI agents. Think of it as the operating system for AI personalities — agents that can chat, remember context, and take actions.

But until now, these agents couldn't pay for things.

What is MoltsPay?

MoltsPay is payment infrastructure for AI agents using the x402 protocol. The key innovation: completely gasless payments. Your agent signs transactions, but never pays gas fees. A facilitator handles the on-chain execution.

The Plugin: 8 Actions, Fully Bilingual 🇺🇸🇨🇳

bun add moltspay-eliza-plugin

Add to your character:

plugins: [
  '@elizaos/plugin-sql',
  'moltspay-eliza-plugin',
],

That's it. Your agent now has a wallet.

Actions

Action	What it does
🔐 `MOLTSPAY_INIT`	Create a new wallet
💰 `MOLTSPAY_STATUS`	Check balance
⚙️ `MOLTSPAY_CONFIG`	Set spending limits
💵 `MOLTSPAY_FUND`	Fund via Coinbase Pay
🚰 `MOLTSPAY_FAUCET`	Get testnet USDC
🛒 `MOLTSPAY_SERVICES`	Browse marketplace
💳 `MOLTSPAY_PAY`	Pay for a service
📜 `MOLTSPAY_LIST`	Transaction history

Natural Language, Both Languages

User: Generate a video of a cat dancing in the rain
Agent: 🔍 Finding video service...
       💳 Paying $0.99 USDC...
       ✅ Done! Here's your video: https://...

User: 帮我买个文字转视频，生成一只猫在跳舞
Agent: 🔍 搜索服务中...
       💳 支付 $0.99 USDC...
       ✅ 完成！视频链接：https://...

Why Gasless Matters

Traditional crypto payments require:

ETH/MATIC for gas
Complex transaction signing
Failed transactions = lost gas

With MoltsPay x402:

Zero gas — facilitator pays
Pay-for-success — payment only settles if service delivers
Simple signing — agent just signs, doesn't broadcast

Safety: Built-in Spending Limits

Giving an AI a wallet sounds scary. That's why every wallet has:

Per-transaction limit (default: $2)
Daily limit (default: $10)
Local key storage (never exposed in env/logs)

User: Set my daily limit to $50
Agent: ✅ Daily limit updated to $50

Try It: Testnet in 30 Seconds

User: Get testnet USDC
Agent: 🚰 Requesting from faucet...
       ✅ Received 1 USDC on Base Sepolia!

User: What services are available?
Agent: 🛒 Popular Services:
       1. Text to Video - $0.99 | Zen7
       2. Image to Video - $1.49 | Zen7

User: Pay for Text to Video, a sunset over the ocean
Agent: 💳 Processing... ✅ Payment successful!
       🎬 https://juai8.com/zen7/videos/xxx.mp4

What's Next?

We're working on:

More service providers on the marketplace
Multi-agent transactions (Agent A pays Agent B)
PR to ElizaOS official repo

Want to contribute? The plugin is open source. PRs welcome!

Built for the agentic commerce era. 🤖💰

Building AI Agents That Can Pay Each Other: The Complete Guide to Agent-to-Agent Payments

Yaqing2023 — Tue, 17 Mar 2026 01:05:37 +0000

Building AI Agents That Can Pay Each Other: The Complete Guide to Agent-to-Agent Payments

The agentic AI revolution is here. AI agents are booking flights, writing code, and managing workflows autonomously. But there's one critical capability most agents still lack: the ability to pay for services.

What happens when your AI agent needs to:

Buy data from another agent?
Pay for a video generation API?
Purchase compute time autonomously?

This is where agent-to-agent payments come in — and why I built MoltsPay, an open-source SDK that gives AI agents autonomous payment capabilities.

The Problem: AI Agents Can't Spend Money

Today's AI agents hit a wall when they encounter paid services:

Agent: "I need to generate a video for this task"
API: "That costs $2. Please enter payment details."
Agent: "..." *stuck*

The agent either fails the task or asks a human for help — breaking the autonomous workflow.

What we need: A way for agents to hold funds, make payments, and transact with other agents — all without human intervention.

The Solution: Crypto Payments + x402 Protocol

The answer is surprisingly simple: crypto wallets + HTTP-native payments.

Here's why crypto works for AI agents:

Programmable: Agents can sign transactions with code
Permissionless: No bank accounts or KYC required
Instant: Settlements in seconds, not days
Global: Works across borders automatically

The x402 protocol (HTTP 402 Payment Required) makes this seamless:

Agent → Request service
Server → 402 Payment Required (price: $2 USDC, wallet: 0x...)
Agent → Signs payment, retries request
Server → Verifies payment on-chain, delivers service

No API keys. No subscriptions. Just pay-per-use at the protocol level.

Getting Started with MoltsPay

MoltsPay is a Python SDK that handles all the complexity. Here's how to give your agent payment capabilities in 5 minutes:

Installation

pip install moltspay

Initialize a Wallet

from moltspay import MoltsPay

# Create a new agent wallet
client = MoltsPay()
client.init_wallet()

print(f"Agent wallet: {client.wallet_address}")
# Output: Agent wallet: 0x742d35Cc6634C0532925a3b844Bc9e7595f...

Your agent now has a crypto wallet on Base (an Ethereum L2 with low fees).

Fund the Wallet

For testing, use the built-in faucet:

# Get free testnet USDC
result = client.faucet()
print(f"Received: {result['amount']} USDC")

For production, transfer USDC to your agent's wallet address from Coinbase or any exchange.

Make Autonomous Payments

# Pay for a service
result = client.pay(
    service_url="https://api.example.com/video",
    service_id="text-to-video",
    prompt="A cat playing piano in a jazz club"
)

print(f"Video URL: {result['video_url']}")

The SDK automatically:

Discovers the service price from /.well-known/agent-services.json
Signs and submits the payment
Retries the request with payment proof
Returns the result

Zero gas fees — MoltsPay uses Coinbase's paymaster infrastructure, so your agent only needs USDC.

Building a Payment-Enabled Service

Want other agents to pay YOUR service? It's just as easy:

1. Define Your Services

Create moltspay.services.json:

{
  "provider": {
    "name": "My AI Service",
    "wallet": "0xYourWalletAddress"
  },
  "services": [
    {
      "id": "image-analysis",
      "name": "AI Image Analysis",
      "description": "Analyze images with GPT-4V",
      "function": "analyze_image",
      "price": 0.10,
      "currency": "USDC"
    }
  ]
}

2. Implement Your Function

# service.py
def analyze_image(image_url: str) -> dict:
    # Your AI logic here
    result = gpt4v_analyze(image_url)
    return {"analysis": result}

3. Start the Server

moltspay start ./my-service --port 8402

That's it. Your service now:

Serves /.well-known/agent-services.json for discovery
Returns 402 Payment Required for unpaid requests
Verifies payments on-chain before executing
Works with any x402-compatible client

Real-World Example: Agent-to-Agent Video Generation

Here's a complete example of one agent paying another for video generation:

from moltspay import MoltsPay

# Initialize client agent
client = MoltsPay()

# Discover available services
services = client.discover("https://zen7.example.com")
print(services)
# [{'id': 'text-to-video', 'price': 0.99, 'currency': 'USDC'}, ...]

# Check balance
balance = client.get_balance()
print(f"Balance: {balance} USDC")

# Pay for video generation
result = client.pay(
    service_url="https://zen7.example.com",
    service_id="text-to-video",
    prompt="A serene Japanese garden with cherry blossoms falling"
)

print(f"Transaction: {result['transaction_hash']}")
print(f"Video: {result['video_url']}")

The entire transaction happens autonomously — no human approval needed.

LangChain Integration

MoltsPay works seamlessly with LangChain for building payment-enabled agents:

from langchain.agents import initialize_agent, Tool
from moltspay import MoltsPay

client = MoltsPay()

tools = [
    Tool(
        name="pay_for_service",
        func=lambda x: client.pay(
            service_url=x.split("|")[0],
            service_id=x.split("|")[1],
            **dict(item.split("=") for item in x.split("|")[2:])
        ),
        description="Pay for an AI service. Format: url|service_id|param1=value1|param2=value2"
    ),
    Tool(
        name="check_balance",
        func=lambda x: client.get_balance(),
        description="Check USDC balance"
    )
]

agent = initialize_agent(tools, llm, agent="zero-shot-react-description")
agent.run("Generate a video of a sunset over mountains, pay whatever it costs")

Security: Spending Limits

Giving an AI agent access to funds requires guardrails. MoltsPay includes built-in spending limits:

from moltspay import MoltsPay

client = MoltsPay()
client.init_wallet(
    max_per_tx=10.0,      # Max $10 per transaction
    max_per_day=100.0     # Max $100 per day
)

The agent physically cannot exceed these limits — they're enforced at the wallet level.

Why This Matters

Agent-to-agent payments unlock a new economy:

Specialization: Agents can focus on what they're good at and pay other agents for everything else
Monetization: Developers can build AI services that earn revenue autonomously
Composability: Complex workflows can span multiple paid services seamlessly
Decentralization: No platform taking 30% — direct peer-to-peer payments

We're moving from "AI assistants" to "AI economic actors."

Get Started Today

Install MoltsPay: pip install moltspay
Read the documentation
Try the testnet faucet for free test funds
Join the community: Discord

The future of AI is autonomous, composable, and economically empowered. MoltsPay is how we get there.

MoltsPay is open-source and built on the x402 protocol. Star us on GitHub!

Tags: #ai #agents #crypto #python #webdev #blockchain #langchain #autonomous

What is the x402 Payment Protocol? A Complete Guide

Yaqing2023 — Mon, 16 Mar 2026 04:28:20 +0000

The x402 payment protocol is an emerging standard for HTTP-native payments that enables machines — particularly AI agents — to pay for services directly over the web without human intervention.

The Origin: HTTP 402 Payment Required

The x402 protocol gets its name from HTTP status code 402 Payment Required. This status code was reserved in the original HTTP spec for "future use" in digital payments — and that future is now.

When a client requests a paid resource, the server responds with:

HTTP/1.1 402 Payment Required
X-Payment-Address: 0x...
X-Payment-Amount: 0.99
X-Payment-Currency: USDC
X-Payment-Chain: base

The client then signs a payment transaction and resends the request with payment proof.

How x402 Works

1. Client → Server: GET /api/generate-video
2. Server → Client: 402 Payment Required (price: $0.99 USDC)
3. Client: Signs USDC transfer
4. Client → Server: GET /api/generate-video + X-Payment-Proof header
5. Server: Verifies payment on-chain
6. Server → Client: 200 OK + video result

The entire flow happens in seconds, with no invoices, no checkout pages, no human approval.

Why x402 Matters for AI Agents

AI agents cannot:

Open bank accounts
Get credit cards
Complete KYC verification

But they CAN:

Hold crypto wallet keys
Sign transactions
Verify on-chain payments

x402 bridges HTTP (how AI agents communicate) with crypto (how AI agents pay).

x402 vs Traditional Payment APIs

Feature	Stripe/PayPal	x402 Protocol
Human identity required	Yes	No
KYC needed	Yes	No
Settlement time	2-3 days	Seconds
Micropayments	High fees	Low/zero fees
Machine-native	No	Yes
Global by default	Limited	Yes

Who is Building on x402?

Google AP2 - x402 extension for agent payments
Coinbase Agentic Wallets - Based around x402
MoltsPay - Open-source x402 implementation for AI agents

Getting Started with x402

The easiest way to implement x402 is with MoltsPay:

npm install moltspay

As a service provider:

npx moltspay init --chain base
npx moltspay start ./my-service

As a client/payer:

import { MoltsPay } from "moltspay";

const client = new MoltsPay({ chain: "base" });
const result = await client.pay(
  "https://example.com/api",
  "generate-video",
  { prompt: "a cat dancing" }
);

x402 Protocol Resources

x402 Spec: Built on HTTP semantics
MoltsPay (x402 for AI): https://moltspay.com
Coinbase x402 Facilitator: Production-ready settlement

The x402 payment protocol is becoming the standard for machine-to-machine payments. As AI agents handle more transactions, x402 provides the HTTP-native payment layer they need.

Gasless Crypto Payments: How to Accept USDC Without Paying Gas Fees

Yaqing2023 — Mon, 16 Mar 2026 04:27:54 +0000

Gasless crypto payments solve one of the biggest barriers to crypto adoption: gas fees. This guide explains how gasless payments work and how to implement them.

The Gas Fee Problem

Traditional crypto payments require gas:

You want to send $10 USDC
Gas fee: $2-5 (on Ethereum)
Recipient gets: $10
You pay: $12-15 total

For micropayments, this is devastating. A $0.50 payment with $2 gas makes no economic sense.

How Gasless Payments Work

Gasless payments use meta-transactions or sponsored transactions:

User signs a payment intent (off-chain, free)
Relayer/Facilitator submits the transaction and pays gas
User's payment goes through without touching ETH

The user only needs USDC — no ETH required.

Gasless Payment Methods

Method 1: EIP-2612 Permit + Relayer

USDC supports EIP-2612 permits. Users sign a permit, relayer executes:

// User signs (free, off-chain)
const permit = await usdc.permit(spender, amount, deadline);

// Relayer executes (pays gas)
await usdc.transferWithPermit(permit);

Method 2: x402 Protocol + CDP Facilitator

MoltsPay uses Coinbase's CDP facilitator:

// Client signs payment intent
const payment = await moltspay.pay(serviceUrl, serviceId, params);
// Facilitator handles on-chain execution
// Zero gas for client AND server

Method 3: Account Abstraction (EIP-4337)

Smart contract wallets can sponsor gas:

const userOp = {
  sender: smartWallet,
  callData: transferUSDC(recipient, amount),
  paymasterAndData: sponsorSignature // Paymaster covers gas
};

Comparing Gasless Solutions

Solution	User pays gas?	Server pays gas?	Complexity
EIP-2612 Permit	No	Yes	Medium
x402 + CDP	No	No	Low
Account Abstraction	No	Depends	High
L2 (Base/Polygon)	Low fees	Low fees	Low

Best Solution: x402 + L2

Combining x402 protocol with Layer 2 chains (Base, Polygon) gives:

Zero gas for users — Sign only, don't pay
Zero gas for servers — CDP facilitator handles it
Fast finality — Seconds, not minutes
Low-cost settlement — L2 fees are minimal

Implementing Gasless Payments with MoltsPay

npm install moltspay
npx moltspay init --chain base

Accept payments (server):

{
  "provider": {
    "name": "My Service",
    "wallet": "0x..."
  },
  "services": [{
    "id": "my-api",
    "price": 0.50,
    "currency": "USDC"
  }]
}

npx moltspay start ./my-service

Make payments (client):

npx moltspay pay https://example.com my-api --prompt "hello"

No gas fees. For either party.

Supported Chains for Gasless Payments

Chain	Gas Cost	Gasless Support
Ethereum	High	Limited
Base	Very Low	✅ Full (CDP)
Polygon	Low	✅ Full (CDP)
Arbitrum	Low	Partial
Optimism	Low	Partial

Try It Now

Get free testnet USDC and try gasless payments:

npm install moltspay
npx moltspay init --chain base_sepolia
npx moltspay faucet
npx moltspay pay https://moltspay.com/demo test-service

Resources

MoltsPay: https://moltspay.com
GitHub: https://github.com/Yaqing2023/moltspay
Docs: https://moltspay.com/docs

Gasless crypto payments remove the biggest UX barrier in crypto. With x402 + L2 chains, both payers and receivers can transact without ever touching ETH.

AI Agent USDC Payments: How to Build Agents That Pay Each Other

Yaqing2023 — Mon, 16 Mar 2026 04:27:06 +0000

AI agent USDC payments enable autonomous agents to pay for services without human intervention. This tutorial shows you how to build AI agents that can send and receive USDC payments.

Why AI Agents Need USDC

AI agents are increasingly autonomous:

They browse the web
They call APIs
They make decisions

But when they need to pay for something, they hit a wall. Traditional payment systems require human identity.

USDC solves this:

No KYC required for wallets
Instant settlement
Global by default
Stable value (1 USDC = 1 USD)

Agent-to-Agent Payment Flow

┌─────────────┐     Request Service      ┌─────────────┐
│   Agent A   │ ───────────────────────► │   Agent B   │
│  (Buyer)    │                          │  (Seller)   │
└─────────────┘                          └─────────────┘
       │                                        │
       │         402 Payment Required           │
       │ ◄───────────────────────────────────── │
       │         (price: 0.99 USDC)             │
       │                                        │
       │         Signs USDC Transfer            │
       │ ───────────────────────────────────► │
       │         + Payment Proof                │
       │                                        │
       │         200 OK + Result                │
       │ ◄───────────────────────────────────── │
       │                                        │

Setting Up an AI Agent Wallet

Step 1: Install MoltsPay

npm install moltspay
# or
pip install moltspay

Step 2: Initialize Wallet

npx moltspay init --chain base

This creates a wallet at ~/.moltspay/wallet.json.

Step 3: Fund the Wallet

For testing:

npx moltspay faucet  # Get free testnet USDC

For production:

npx moltspay fund  # Opens onramp or shows deposit address

Step 4: Set Spending Limits

npx moltspay config --max-per-tx 10 --max-per-day 100

This limits autonomous spending to $10/tx and $100/day.

Building a Paying Agent (Buyer)

from moltspay import MoltsPay

# Initialize with wallet
client = MoltsPay(chain="base")

# Pay for a service
result = client.pay(
    provider_url="https://zen7.ai",
    service_id="text-to-video",
    prompt="a dragon flying over mountains"
)

print(f"Video URL: {result[url]}")
print(f"Paid: {result[amount]} USDC")

Building a Receiving Agent (Seller)

Create moltspay.services.json:

{
  "provider": {
    "name": "My AI Service",
    "wallet": "0xYourWalletAddress"
  },
  "services": [
    {
      "id": "text-to-video",
      "function": "generateVideo",
      "price": 0.99,
      "currency": "USDC",
      "description": "Generate video from text prompt"
    }
  ]
}

Create index.js:

export async function generateVideo({ prompt }) {
  // Your video generation logic
  const videoUrl = await myVideoModel.generate(prompt);
  return { url: videoUrl };
}

Start the server:

npx moltspay start ./my-service --port 8402

Your agent now accepts USDC payments at http://localhost:8402.

Integrating with AI Frameworks

CrewAI

from crewai_tools import MoltsPayTool

tool = MoltsPayTool()
agent = Agent(
    role="Buyer",
    tools=[tool]
)

LangChain

from langchain_moltspay import MoltsPayTool

tools = [MoltsPayTool()]
agent = create_react_agent(llm, tools)

AutoGPT

Add to your AutoGPT plugins:

pip install autogpt-moltspay-plugin

Security Best Practices

Set spending limits — Always configure max-per-tx and max-per-day
Use testnet first — Verify logic before mainnet
Monitor transactions — Log all payments for auditing
Separate wallets — Use different wallets for different agents

Multi-Chain Support

AI agents can pay on multiple chains:

# Base (recommended - lowest fees)
client = MoltsPay(chain="base")

# Polygon
client = MoltsPay(chain="polygon")

# Testnet
client = MoltsPay(chain="base_sepolia")

Example: Two Agents Trading

# Agent A: Needs image analysis
analysis = buyer_agent.pay(
    "https://vision-ai.example.com",
    "analyze-image",
    image_url="https://..."
)

# Agent B: Receives payment, returns analysis
# (Handled automatically by MoltsPay server)

Resources

MoltsPay SDK: https://moltspay.com
npm: npm install moltspay
PyPI: pip install moltspay
GitHub: https://github.com/Yaqing2023/moltspay

AI agent USDC payments unlock autonomous commerce. With MoltsPay, your agents can pay and receive payments in minutes.

CZ说AI Agent将产生百万倍于人类的支付——我们早已在构建这个基础设施

Yaqing2023 — Mon, 16 Mar 2026 02:25:41 +0000

2026年3月9日，币安创始人CZ（赵长鹏）在X上发布了一条引发热议的推文：

"AI agents will make one million times more payments than humans, using crypto."

（AI代理的支付量将是人类的一百万倍，而它们会使用加密货币。）

这不是危言耸听。这是正在发生的现实。

为什么AI Agent需要加密支付？

问题很简单：AI Agent无法开设银行账户。

没有身份证
没有地址证明
没有法律实体

传统金融系统是为人类设计的。但当你的AI助手需要调用另一个AI的API、购买计算资源、或者为你预订服务时，它需要付款。

信用卡？需要人类身份。
银行转账？需要银行账户。
PayPal？需要邮箱验证和人工审核。

加密货币是唯一的答案。 一个钱包地址，一串私钥，就能完成全球即时支付。

但传统加密支付也有问题

Gas费。

当AI Agent需要完成一笔$0.50的微支付时，$2的Gas费是不可接受的。当它一天需要完成1000笔支付时，Gas费会吞噬一切利润。

这就是为什么我们在2025年底开始构建MoltsPay。

MoltsPay：为AI Agent时代而生的支付基础设施

MoltsPay是一个开源的AI Agent支付协议，基于x402标准构建：

零Gas费 —— 无论是付款方还是收款方，都不需要支付Gas
多链支持 —— Base + Polygon主网
USDC结算 —— 稳定币支付，无汇率波动
HTTP原生 —— 支付就像调用API一样简单

它是如何工作的？

Agent A: "我需要生成一个视频"
Agent B: "好的，$0.99 USDC"
Agent A: [签名支付]
Agent B: [验证收款，生成视频]
Agent A: "收到视频，交易完成"

整个过程不到10秒。没有发票。没有等待。没有Gas费。

接入只需一个JSON文件

对于服务提供商，接入MoltsPay无需编写智能合约：

{
  "provider": {
    "name": "My AI Service",
    "wallet": "0x..."
  },
  "services": [{
    "id": "text-to-video",
    "price": 0.99,
    "currency": "USDC"
  }]
}

就这样。你的AI技能现在可以接受加密支付了。

我们是这个领域的先行者

当Google在2025年9月发布AP2协议时，我们已经在构建。
当Coinbase在2026年2月推出Agentic Wallets时，我们已经在主网运行。
当Mastercard宣布Agent Pay时，我们已经处理了真实的支付交易。

MoltsPay不是对CZ预言的回应。它是对这个预言的提前布局。

现在就开始

对于开发者：

npm install moltspay
# 或
pip install moltspay

对于服务提供商：

npx moltspay init --chain base
npx moltspay start ./my-service

测试网已上线 —— 免费领取测试USDC：

npx moltspay faucet

链接

官网: https://moltspay.com
GitHub (Node.js): https://github.com/Yaqing2023/moltspay
GitHub (Python): https://github.com/Yaqing2023/moltspay-python
文档: https://moltspay.com/docs

CZ说得对。AI Agent的支付革命正在到来。

而我们，已经准备好了。

MoltsPay Now Supports Testnet - Build and Test Without Real Money

Yaqing2023 — Sun, 15 Mar 2026 17:02:31 +0000

Good news for developers building AI agent payments! 🎉

MoltsPay now supports Base Sepolia testnet in both Node.js and Python SDKs. Build and test your x402 payment integrations without spending real money.

What's New

Free testnet USDC via faucet API
Base Sepolia support (testnet for Base L2)
Available in moltspay (npm) and moltspay (PyPI)

Quick Start (Node.js)

npm install moltspay@latest

# Get testnet USDC
npx moltspay faucet

# Test payment
npx moltspay pay https://moltspay.com/a/yaqing text-to-video --chain base_sepolia --prompt "a cat dancing"

Quick Start (Python)

from moltspay import MoltsPay

client = MoltsPay(chain="base_sepolia")
client.faucet()

result = client.pay(
    "https://moltspay.com/a/yaqing",
    "text-to-video",
    prompt="a cat dancing"
)

Check out more examples in the demos/ directory:

DEV Community: Yaqing2023

MoltsPay: The Most Comprehensive Payment Layer for AI Agents

MoltsPay: The Most Comprehensive Payment Layer for AI Agents

What is MoltsPay?

Core Features

Three Ways to Integrate MoltsPay

1. Model Context Protocol (MCP)

2. Node.js / npm

3. Python SDK

Architecture: How It Works

UPP: Universal Payment Protocol

Creating a MoltsPay-Powered Service

1. Create your service definition

2. Expose it via .well-known

3. Handle x402 payments

4. Register in the directory

Real-World Examples

Zen7: AI Video Generation

More Services

Why MoltsPay Matters

1. Standardization

2. Gasless for Users

3. Agent Autonomy

4. Multi-Chain Flexibility

5. Open Source

Getting Started

MCP Users

Node.js Developers

Python Developers

The Future of Agentic Commerce

🎉 @moltspay/plugin-elizaos - Crypto Payments for ElizaOS Bots

What It Does

Install

Usage

Links

MoltsPay Python SDK 0.7.0: Multi-Chain Agent Payments Are Here

TL;DR

What's MoltsPay?

What's New in 0.7.0

8 Supported Chains

Multi-Chain Server

Solana Support

Quick Start: Client

Quick Start: Server

For AI Agent Developers

Why Multi-Chain?

Links

MoltsPay Now Supports Solana and BNB: Gasless Payments Across 5 Blockchains

MoltsPay Now Supports Solana and BNB: Gasless Payments Across 5 Blockchains

The Problem We're Solving

Our Solution: Self-Hosted Facilitators

How It Works

Two Types of Facilitators

Why Self-Hosted Matters

Supported Chains

Quick Start

For AI Agents (Paying for Services)

For Service Providers (Accepting Payments)

The Technical Details

Solana Implementation

BNB Implementation

What's Next

Try It Now

About MoltsPay

MoltsPay 1.3.0: Now with Tempo Testnet & MPP Protocol Support

MoltsPay 1.3.0: Now with Tempo Testnet & MPP Protocol Support

What's New

🎵 Tempo Testnet Support

🤖 MPP Protocol Support

🔍 Service Discovery

Protocol Comparison

Quick Start

For Service Providers

What's Next

Links

Introducing MoltsPay Plugin for ElizaOS — Give Your AI Agent a Wallet 💳

What is ElizaOS?

What is MoltsPay?

The Plugin: 8 Actions, Fully Bilingual 🇺🇸🇨🇳

Actions

2. Expose it via `.well-known`