Quickstart

Execute your first autonomous MPP payment in 10 minutes.

Prerequisites

Node.js 18+ or Python 3.10+
Solana wallet with USDC balance
OpenClaw installed (for Python integration)
Basic understanding of the Machine Payments Protocol

What you'll build

An OpenClaw agent that autonomously pays for premium API access using MPP with Solana settlement.

Option 1: TypeScript SDK

Install

npm install @moltmpp/sdk @solana/web3.js

Configure wallet

import { MoltMPPClient } from '@moltmpp/sdk'
import { Keypair } from '@solana/web3.js'
import fs from 'fs'

// Load Solana wallet
const secretKey = JSON.parse(fs.readFileSync('~/.config/solana/id.json', 'utf8'))
const wallet = Keypair.fromSecretKey(new Uint8Array(secretKey))

// Initialize MoltMPP client
const mpp = new MoltMPPClient({
  solanaRpc: 'https://api.mainnet-beta.solana.com',
  wallet: wallet,
  policies: {
    maxPerTransaction: 100_000,  // 100 USDC (6 decimals)
    dailyLimit: 1_000_000         // 1000 USDC
  }
})

Make your first MPP payment

// Agent pays for premium weather API access
const result = await mpp.payForResource({
  url: 'https://api.weather.com/premium/forecast',
  parameters: {
    location: 'San Francisco',
    days: 7
  }
})

console.log('Payment Result:')
console.log(`  Solana signature: ${result.signature}`)
console.log(`  Amount paid: ${result.amountUSDC} USDC`)
console.log(`  Service: ${result.service}`)
console.log(`  Receipt: ${result.receipt}`)
console.log(`  Resource delivered: ${result.resource ? 'Yes' : 'No'}`)

Verify settlement

// Check transaction on Solana
const tx = await mpp.getTransaction(result.signature)

console.log('Transaction Details:')
console.log(`  Status: ${tx.status}`)  // finalized
console.log(`  Block time: ${tx.blockTime}`)
console.log(`  Fee: ${tx.fee} lamports`)
console.log(`  Confirmations: ${tx.confirmations}`)

Option 2: OpenClaw Integration (Python)

Install

pip install openclaw moltmpp-python

Configure agent

from openclaw import Agent
from moltmpp import SolanaPaymentProvider
import os

# Initialize payment provider
provider = SolanaPaymentProvider(
    network="mainnet-beta",
    wallet_path=os.path.expanduser("~/.config/solana/id.json"),
    policies={
        "max_per_transaction": 100.00,  # USD
        "daily_limit": 1000.00           # USD
    }
)

# Create agent with MPP payment capability
agent = Agent(
    name="research_assistant",
    providers=[provider]
)

Execute autonomous payment

# Agent discovers MPP service and pays autonomously
result = agent.run("""
I need a 7-day weather forecast for San Francisco.

Find a premium weather API that accepts MPP payments,
authorize payment if under $10,
and return the forecast data.
""")

print(f"Payment signature: {result.payment.signature}")
print(f"Amount paid: {result.payment.amount_usdc} USDC")
print(f"Weather data: {result.data}")

Monitor transaction

# Query transaction details
tx = provider.get_transaction(result.payment.signature)

print(f"Status: {tx.status}")
print(f"Settled in: {tx.latency_ms}ms")
print(f"Blockchain: Solana mainnet-beta")

Understanding the MPP flow

When your agent makes an MPP payment, here's what happens:

1. Resource request

Agent requests a paid resource:

GET /api/premium/forecast?location=SF HTTP/1.1
Host: api.weather.com

2. Payment required (402)

Service responds with payment requirements:

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

{
  "amount": "5.00",
  "currency": "USD",
  "payment_methods": [{
    "type": "crypto",
    "blockchain": "solana",
    "token": "USDC",
    "recipient": "DsV...mK9"
  }]
}

3. Payment execution

MoltMPP constructs and submits Solana transaction:

// Automatically handled by MoltMPP
const tx = {
  payer: agentWallet,
  recipient: merchantWallet,
  amount: 5_000_000,  // 5 USDC (6 decimals)
  token: USDC_MINT
}

const signature = await connection.sendTransaction(tx)
// Signature: 5Kx...9mQ

4. Retry with credential

Agent retries with payment proof:

GET /api/premium/forecast?location=SF HTTP/1.1
Host: api.weather.com
MPP-Payment-Credential: solana:signature:5Kx...9mQ

5. Resource delivery

Service verifies on-chain payment and delivers resource:

HTTP/1.1 200 OK
MPP-Receipt: <signed_proof_of_delivery>

{
  "forecast": { ... },
  "payment_confirmed": true
}

Approval policies

Control autonomous payment behavior with policies:

# ~/.moltmpp/policies.yaml
policies:
  - name: auto_approve_small
    conditions:
      max_value_usd: 10
    action: auto_approve

  - name: require_approval_medium
    conditions:
      min_value_usd: 10
      max_value_usd: 100
    action: require_human_approval
    notification:
      channels: [email]
      timeout: 3600

  - name: block_large
    conditions:
      min_value_usd: 100
    action: reject

Use in your agent:

const mpp = new MoltMPPClient({
  solanaRpc: 'https://api.mainnet-beta.solana.com',
  wallet: wallet,
  policiesPath: '~/.moltmpp/policies.yaml'
})

Testing on devnet

Use Solana devnet for testing without spending real funds:

const mpp = new MoltMPPClient({
  solanaRpc: 'https://api.devnet.solana.com',
  wallet: wallet,
  network: 'devnet'
})

Get devnet USDC:

# Airdrop SOL for fees
solana airdrop 2 <your-wallet-address> --url devnet

# Mint devnet USDC (visit faucet)
# https://spl-token-faucet.com/?token-name=USDC

Complete example

import { MoltMPPClient } from '@moltmpp/sdk'
import { Keypair } from '@solana/web3.js'
import fs from 'fs'

async function main() {
  // Load wallet
  const secretKey = JSON.parse(
    fs.readFileSync('~/.config/solana/id.json', 'utf8')
  )
  const wallet = Keypair.fromSecretKey(new Uint8Array(secretKey))

  // Initialize client
  const mpp = new MoltMPPClient({
    solanaRpc: 'https://api.devnet.solana.com',
    wallet: wallet,
    network: 'devnet',
    policies: {
      maxPerTransaction: 10_000,  // 10 USDC
      dailyLimit: 100_000          // 100 USDC
    }
  })

  try {
    // Execute MPP payment
    console.log('Requesting premium API access...')

    const result = await mpp.payForResource({
      url: 'https://api.example.com/premium/data',
      parameters: { query: 'test' }
    })

    console.log(`✓ Payment successful: ${result.signature}`)
    console.log(`✓ Amount: ${result.amountUSDC} USDC`)
    console.log(`✓ Settlement: ${result.latencyMs}ms`)
    console.log(`✓ Resource delivered: Yes`)

    // Verify on-chain
    const tx = await mpp.getTransaction(result.signature)
    console.log(`✓ Confirmations: ${tx.confirmations}`)

  } catch (error) {
    if (error.code === 'INSUFFICIENT_FUNDS') {
      console.error('Insufficient USDC balance')
    } else if (error.code === 'PAYMENT_REJECTED') {
      console.error(`Payment rejected by policy: ${error.policyName}`)
    } else if (error.code === 'SERVICE_UNAVAILABLE') {
      console.error('MPP service unavailable')
    } else {
      console.error(`Payment failed: ${error.message}`)
    }
  }
}

main()

Run the example

# Install dependencies
npm install

# Set up wallet (if needed)
solana-keygen new --outfile ~/.config/solana/id.json

# Get devnet funds
solana airdrop 2 --url devnet

# Run example
npx ts-node quickstart.ts

What's next?

Now that you've executed your first MPP payment:

OpenClaw Integration: Build autonomous agent workflows
Approval Policies: Configure payment authorization rules
Service Discovery: Find MPP-enabled APIs
Architecture: Deep-dive into MPP + Solana integration

Troubleshooting

"Insufficient USDC balance"

Check wallet balance:

const balance = await mpp.getUSDCBalance()
console.log(`USDC balance: ${balance}`)

"MPP-Payment-Credential invalid"

Transaction may not be finalized. Wait for confirmation:

await mpp.connection.confirmTransaction(signature, 'finalized')

"Service does not support MPP"

Verify the service supports Machine Payments Protocol:

curl -I https://api.example.com/resource
# Look for: MPP-Version header

"Policy rejected payment"

Check your policies configuration:

const evaluation = await mpp.evaluatePolicy({
  amount: 5_000_000,
  merchant: "DsV...mK9"
})

console.log(`Policy: ${evaluation.matchedPolicy}`)
console.log(`Action: ${evaluation.action}`)

Get help

Documentation: docs.moltmpp.dev
Discord: discord.gg/moltmpp
GitHub Issues: github.com/moltmpp/sdk/issues
Email: [email protected]

PreviousIntroduction NextArchitecture

Last updated 34 minutes ago

Was this helpful?

Good morning

hashtagPrerequisites

hashtagWhat you'll build

hashtagOption 1: TypeScript SDK

hashtagInstall

hashtagConfigure wallet

hashtagMake your first MPP payment

hashtagVerify settlement

hashtagOption 2: OpenClaw Integration (Python)

hashtagInstall

hashtagConfigure agent

hashtagExecute autonomous payment

hashtagMonitor transaction

hashtagUnderstanding the MPP flow

hashtag1. Resource request

hashtag2. Payment required (402)

hashtag3. Payment execution

hashtag4. Retry with credential

hashtag5. Resource delivery

hashtagApproval policies

hashtagTesting on devnet

hashtagComplete example

hashtagRun the example

hashtagWhat's next?

hashtagTroubleshooting

hashtagGet help

Prerequisites

What you'll build

Option 1: TypeScript SDK

Install

Configure wallet

Make your first MPP payment

Verify settlement

Option 2: OpenClaw Integration (Python)

Install

Configure agent

Execute autonomous payment

Monitor transaction

Understanding the MPP flow

1. Resource request

2. Payment required (402)

3. Payment execution

4. Retry with credential

5. Resource delivery

Approval policies

Testing on devnet

Complete example

Run the example

What's next?

Troubleshooting

Get help