Build a Paid API with x402
USDC Micropayments: Complete Tutorial

# Create a new Hono project for Cloudflare Workers
npm create hono@latest my-paid-api

# When prompted:
#   Which template? -> cloudflare-workers
#   Do you want to install dependencies? -> yes

cd my-paid-api

my-paid-api/
  src/
    index.ts          # Main application entry
  wrangler.toml       # Cloudflare Workers config
  package.json
  tsconfig.json

import { Hono } from 'hono'

const app = new Hono()

app.get('/', (c) => {
  return c.json({
    name: 'my-paid-api',
    version: '1.0.0',
    status: 'running',
  })
})

export default app

# Start the development server
npm run dev

# Test it
curl http://localhost:8787/
# {"name":"my-paid-api","version":"1.0.0","status":"running"}

# Install core x402 packages
npm install x402 @coinbase/x402

# Install chain-specific verification libraries
npm install ethers @solana/web3.js @solana/spl-token

# Install type definitions (dev)
npm install -D @types/node

{
  "dependencies": {
    "hono": "^4.7.0",
    "x402": "^0.3.0",
    "@coinbase/x402": "^0.2.0",
    "ethers": "^6.13.0",
    "@solana/web3.js": "^1.98.0",
    "@solana/spl-token": "^0.4.0"
  }
}

// src/middleware/x402.ts
import { Context, Next } from 'hono'
import { ethers } from 'ethers'

// Configuration interface
interface X402Config {
  walletAddress: string        // Your USDC receiving address
  network: 'base' | 'solana'   // Primary network
  rpcUrl: string               // RPC endpoint for verification
  usdcContract: string         // USDC contract address on the chain
}

// Payment requirement returned in 402 response
interface PaymentRequirement {
  scheme: 'exact'
  network: string
  maxAmountRequired: string
  resource: string
  description: string
  mimeType: string
  payTo: string
  maxTimeoutSeconds: number
  asset: string
  extra?: Record<string, unknown>
}

// Base mainnet USDC configuration
const BASE_CONFIG: X402Config = {
  walletAddress: '', // Set from environment
  network: 'base',
  rpcUrl: 'https://mainnet.base.org',
  usdcContract: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
}

// ERC-20 Transfer event ABI for parsing
const TRANSFER_EVENT_ABI = [
  'event Transfer(address indexed from, address indexed to, uint256 value)',
]

/**
 * Verify a USDC payment on Base (EVM) by checking the transaction receipt.
 * Returns the verified payment amount or null if verification fails.
 */
async function verifyBasePayment(
  txHash: string,
  expectedRecipient: string,
  expectedAmount: string,
  rpcUrl: string,
  usdcContract: string
): Promise<{ amount: string; from: string } | null> {
  try {
    const provider = new ethers.JsonRpcProvider(rpcUrl)
    const receipt = await provider.getTransactionReceipt(txHash)

    if (!receipt || receipt.status !== 1) {
      return null // Transaction failed or not found
    }

    // Parse USDC Transfer events from the receipt logs
    const iface = new ethers.Interface(TRANSFER_EVENT_ABI)

    for (const log of receipt.logs) {
      // Only check logs from the USDC contract
      if (log.address.toLowerCase() !== usdcContract.toLowerCase()) {
        continue
      }

      try {
        const parsed = iface.parseLog({
          topics: [...log.topics],
          data: log.data,
        })

        if (
          parsed?.name === 'Transfer' &&
          parsed.args.to.toLowerCase() === expectedRecipient.toLowerCase()
        ) {
          const paidAmount = ethers.formatUnits(parsed.args.value, 6) // USDC has 6 decimals
          if (parseFloat(paidAmount) >= parseFloat(expectedAmount)) {
            return { amount: paidAmount, from: parsed.args.from }
          }
        }
      } catch {
        continue // Skip non-Transfer logs
      }
    }

    return null // No matching transfer found
  } catch {
    return null // RPC error
  }
}

/**
 * x402 middleware factory for Hono.
 * Wraps any route with USDC payment gating.
 *
 * Usage:
 *   app.get('/api/data', x402Middleware('0.05', 'Premium data endpoint'), handler)
 */
export function x402Middleware(
  amountUSDC: string,
  description: string,
  config?: Partial<X402Config>
) {
  return async (c: Context, next: Next) => {
    const walletAddress = config?.walletAddress
      || c.env?.WALLET_ADDRESS
      || BASE_CONFIG.walletAddress

    const rpcUrl = config?.rpcUrl || c.env?.BASE_RPC_URL || BASE_CONFIG.rpcUrl
    const usdcContract = config?.usdcContract || BASE_CONFIG.usdcContract
    const network = config?.network || 'base'

    // Check for payment signature header (x402 V2 uses X-PAYMENT)
    const paymentHeader = c.req.header('X-PAYMENT')
      || c.req.header('X-PAYMENT-PROOF')
      || c.req.header('Payment')

    if (!paymentHeader) {
      // No payment proof: return 402 Payment Required
      const amountInSmallestUnit = (
        parseFloat(amountUSDC) * 1_000_000
      ).toString()

      const paymentRequirements: PaymentRequirement[] = [
        {
          scheme: 'exact',
          network: network,
          maxAmountRequired: amountInSmallestUnit,
          resource: c.req.url,
          description: description,
          mimeType: 'application/json',
          payTo: walletAddress,
          maxTimeoutSeconds: 300,
          asset: usdcContract,
        },
      ]

      // Set x402 response headers
      c.header('X-PAYMENT-NETWORK', network)
      c.header('X-PAYMENT-TOKEN', 'USDC')
      c.header('X-PAYMENT-ADDRESS', walletAddress)
      c.header('X-PAYMENT-AMOUNT', amountInSmallestUnit)
      c.header('X-PAYMENT-DECIMALS', '6')

      return c.json(
        {
          error: 'payment_required',
          amount: amountUSDC,
          currency: 'USDC',
          network: network,
          address: walletAddress,
          description: description,
          expires_in: 300,
          paymentRequirements,
          x402Version: 2,
        },
        402
      )
    }

    // Payment proof present: verify on-chain
    let paymentData: string
    try {
      // x402 V2 sends base64-encoded payment payload
      const decoded = atob(paymentHeader)
      const payload = JSON.parse(decoded)
      paymentData = payload.transaction || payload.txHash || paymentHeader
    } catch {
      // V1 format or raw transaction hash
      paymentData = paymentHeader
    }

    // Verify the payment on Base
    const verification = await verifyBasePayment(
      paymentData,
      walletAddress,
      amountUSDC,
      rpcUrl,
      usdcContract
    )

    if (!verification) {
      return c.json(
        {
          error: 'payment_verification_failed',
          message: 'Could not verify USDC payment on-chain.',
          hint: 'Ensure the transaction is confirmed, sent the correct amount, and targets the correct address.',
        },
        400
      )
    }

    // Attach payment info to context for downstream handlers
    c.set('payment', {
      txHash: paymentData,
      amount: verification.amount,
      from: verification.from,
      network: network,
      currency: 'USDC',
    })

    await next()
  }
}

// src/index.ts
import { Hono } from 'hono'
import { cors } from 'hono/cors'
import { x402Middleware } from './middleware/x402'

type Bindings = {
  WALLET_ADDRESS: string
  BASE_RPC_URL: string
}

const app = new Hono<{ Bindings: Bindings }>()

// Enable CORS for agent clients
app.use('*', cors())

// Public endpoint: health check
app.get('/', (c) => {
  return c.json({
    name: 'my-paid-api',
    version: '1.0.0',
    status: 'running',
    x402: true,
    pricing: {
      '/api/search': '$0.003/query',
      '/api/premium-data': '$0.05/request',
      '/api/bulk-export': '$0.50/export',
    },
  })
})

// x402-protected endpoint: $0.003 per search query
app.get(
  '/api/search',
  x402Middleware('0.003', 'SERP search query'),
  async (c) => {
    const query = c.req.query('q') || 'default'
    const payment = c.get('payment')

    // Your actual API logic here
    return c.json({
      query,
      results: [
        { title: 'Result 1', url: 'https://example.com/1' },
        { title: 'Result 2', url: 'https://example.com/2' },
      ],
      payment: {
        tx_hash: payment.txHash,
        amount: payment.amount,
        network: payment.network,
      },
    })
  }
)

// x402-protected endpoint: $0.05 per premium data request
app.get(
  '/api/premium-data',
  x402Middleware('0.05', 'Premium data access'),
  async (c) => {
    const payment = c.get('payment')

    return c.json({
      data: { /* your premium data */ },
      payment: {
        tx_hash: payment.txHash,
        amount: payment.amount,
      },
    })
  }
)

// x402-protected endpoint: $0.50 per bulk export
app.post(
  '/api/bulk-export',
  x402Middleware('0.50', 'Bulk data export'),
  async (c) => {
    const body = await c.req.json()
    const payment = c.get('payment')

    return c.json({
      export_id: crypto.randomUUID(),
      status: 'processing',
      records: body.ids?.length || 0,
      payment: {
        tx_hash: payment.txHash,
        amount: payment.amount,
      },
    })
  }
)

export default app

// src/middleware/solana-verify.ts
import {
  Connection,
  PublicKey,
  ParsedTransactionWithMeta,
} from '@solana/web3.js'

// USDC on Solana mainnet
const SOLANA_USDC_MINT = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'

interface SolanaPaymentResult {
  amount: string
  from: string
  signature: string
}

/**
 * Verify a USDC payment on Solana by parsing the transaction.
 * Returns verified payment details or null if verification fails.
 */
export async function verifySolanaPayment(
  signature: string,
  expectedRecipient: string,
  expectedAmount: string,
  rpcUrl: string = 'https://api.mainnet-beta.solana.com'
): Promise<SolanaPaymentResult | null> {
  try {
    const connection = new Connection(rpcUrl, 'confirmed')

    // Fetch the parsed transaction
    const tx: ParsedTransactionWithMeta | null =
      await connection.getParsedTransaction(signature, {
        maxSupportedTransactionVersion: 0,
      })

    if (!tx || tx.meta?.err) {
      return null // Transaction not found or failed
    }

    // Look through inner instructions for SPL token transfers
    const instructions = [
      ...(tx.transaction.message.instructions || []),
      ...(tx.meta?.innerInstructions?.flatMap((ix) => ix.instructions) || []),
    ]

    for (const ix of instructions) {
      // Check for parsed SPL token transfer instructions
      if ('parsed' in ix && ix.parsed?.type === 'transferChecked') {
        const info = ix.parsed.info

        // Verify it is USDC (correct mint)
        if (info.mint !== SOLANA_USDC_MINT) {
          continue
        }

        // Verify the recipient matches (token account owner)
        // Note: the destination is a token account, not the wallet directly
        const destOwner = await getTokenAccountOwner(
          connection,
          new PublicKey(info.destination)
        )

        if (destOwner?.toLowerCase() !== expectedRecipient.toLowerCase()) {
          continue
        }

        // Verify the amount (USDC has 6 decimals on Solana)
        const paidAmount = parseFloat(info.tokenAmount.uiAmountString)
        if (paidAmount >= parseFloat(expectedAmount)) {
          return {
            amount: info.tokenAmount.uiAmountString,
            from: info.authority || info.source,
            signature,
          }
        }
      }

      // Also check simple 'transfer' type (without checked)
      if ('parsed' in ix && ix.parsed?.type === 'transfer') {
        const info = ix.parsed.info
        if (info.destination?.toLowerCase() === expectedRecipient.toLowerCase()) {
          const paidLamports = parseInt(info.amount || '0')
          const paidAmount = paidLamports / 1_000_000 // 6 decimals
          if (paidAmount >= parseFloat(expectedAmount)) {
            return {
              amount: paidAmount.toString(),
              from: info.authority || info.source,
              signature,
            }
          }
        }
      }
    }

    return null // No matching USDC transfer found
  } catch (error) {
    console.error('Solana verification error:', error)
    return null
  }
}

/**
 * Get the owner of an SPL token account.
 */
async function getTokenAccountOwner(
  connection: Connection,
  tokenAccount: PublicKey
): Promise<string | null> {
  try {
    const accountInfo = await connection.getParsedAccountInfo(tokenAccount)
    if (
      accountInfo.value?.data &&
      'parsed' in accountInfo.value.data
    ) {
      return accountInfo.value.data.parsed.info.owner || null
    }
    return null
  } catch {
    return null
  }
}

// src/middleware/x402-dual.ts
import { Context, Next } from 'hono'
import { ethers } from 'ethers'
import { verifySolanaPayment } from './solana-verify'

interface DualNetworkConfig {
  base: {
    walletAddress: string
    rpcUrl: string
    usdcContract: string
  }
  solana: {
    walletAddress: string  // Solana pubkey
    rpcUrl: string
  }
}

const DEFAULT_CONFIG: DualNetworkConfig = {
  base: {
    walletAddress: '',
    rpcUrl: 'https://mainnet.base.org',
    usdcContract: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
  },
  solana: {
    walletAddress: '',
    rpcUrl: 'https://api.mainnet-beta.solana.com',
  },
}

const TRANSFER_EVENT_ABI = [
  'event Transfer(address indexed from, address indexed to, uint256 value)',
]

/**
 * Dual-network x402 middleware.
 * Supports both Base (EVM) and Solana for USDC payments.
 */
export function x402DualMiddleware(
  amountUSDC: string,
  description: string,
  config?: Partial<DualNetworkConfig>
) {
  return async (c: Context, next: Next) => {
    // Resolve config from environment or defaults
    const baseWallet = config?.base?.walletAddress
      || c.env?.BASE_WALLET_ADDRESS || ''
    const solanaWallet = config?.solana?.walletAddress
      || c.env?.SOLANA_WALLET_ADDRESS || ''
    const baseRpc = config?.base?.rpcUrl
      || c.env?.BASE_RPC_URL || DEFAULT_CONFIG.base.rpcUrl
    const solanaRpc = config?.solana?.rpcUrl
      || c.env?.SOLANA_RPC_URL || DEFAULT_CONFIG.solana.rpcUrl
    const usdcContract = config?.base?.usdcContract
      || DEFAULT_CONFIG.base.usdcContract

    // Check for payment header
    const paymentHeader = c.req.header('X-PAYMENT')
      || c.req.header('X-PAYMENT-PROOF')
      || c.req.header('Payment')

    if (!paymentHeader) {
      // Return 402 with payment options for BOTH networks
      const amountRaw = (parseFloat(amountUSDC) * 1_000_000).toString()

      return c.json(
        {
          error: 'payment_required',
          amount: amountUSDC,
          currency: 'USDC',
          description,
          expires_in: 300,
          x402Version: 2,
          networks: {
            base: {
              address: baseWallet,
              usdcContract,
              chainId: 8453,
              estimatedFee: '<$0.01',
              estimatedFinality: '~2s',
            },
            solana: {
              address: solanaWallet,
              usdcMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
              estimatedFee: '<$0.001',
              estimatedFinality: '~400ms',
            },
          },
          paymentRequirements: [
            {
              scheme: 'exact',
              network: 'base',
              maxAmountRequired: amountRaw,
              resource: c.req.url,
              description,
              payTo: baseWallet,
              maxTimeoutSeconds: 300,
              asset: usdcContract,
            },
            {
              scheme: 'exact',
              network: 'solana',
              maxAmountRequired: amountRaw,
              resource: c.req.url,
              description,
              payTo: solanaWallet,
              maxTimeoutSeconds: 300,
              asset: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
            },
          ],
        },
        402
      )
    }

    // Determine which network the payment was made on
    const network = (
      c.req.header('X-PAYMENT-NETWORK') || 'base'
    ).toLowerCase()

    // Decode payment proof
    let txData: string
    try {
      const decoded = atob(paymentHeader)
      const payload = JSON.parse(decoded)
      txData = payload.transaction || payload.txHash || paymentHeader
    } catch {
      txData = paymentHeader
    }

    // Verify on the correct chain
    if (network === 'solana') {
      const result = await verifySolanaPayment(
        txData,
        solanaWallet,
        amountUSDC,
        solanaRpc
      )

      if (!result) {
        return c.json(
          { error: 'payment_verification_failed', network: 'solana' },
          400
        )
      }

      c.set('payment', {
        txHash: result.signature,
        amount: result.amount,
        from: result.from,
        network: 'solana',
        currency: 'USDC',
      })
    } else {
      // Default: verify on Base
      const result = await verifyBasePayment(
        txData,
        baseWallet,
        amountUSDC,
        baseRpc,
        usdcContract
      )

      if (!result) {
        return c.json(
          { error: 'payment_verification_failed', network: 'base' },
          400
        )
      }

      c.set('payment', {
        txHash: txData,
        amount: result.amount,
        from: result.from,
        network: 'base',
        currency: 'USDC',
      })
    }

    await next()
  }
}

// Base verification (same as before, inlined for self-contained module)
async function verifyBasePayment(
  txHash: string,
  expectedRecipient: string,
  expectedAmount: string,
  rpcUrl: string,
  usdcContract: string
): Promise<{ amount: string; from: string } | null> {
  try {
    const provider = new ethers.JsonRpcProvider(rpcUrl)
    const receipt = await provider.getTransactionReceipt(txHash)
    if (!receipt || receipt.status !== 1) return null

    const iface = new ethers.Interface(TRANSFER_EVENT_ABI)
    for (const log of receipt.logs) {
      if (log.address.toLowerCase() !== usdcContract.toLowerCase()) continue
      try {
        const parsed = iface.parseLog({
          topics: [...log.topics],
          data: log.data,
        })
        if (
          parsed?.name === 'Transfer' &&
          parsed.args.to.toLowerCase() === expectedRecipient.toLowerCase()
        ) {
          const paidAmount = ethers.formatUnits(parsed.args.value, 6)
          if (parseFloat(paidAmount) >= parseFloat(expectedAmount)) {
            return { amount: paidAmount, from: parsed.args.from }
          }
        }
      } catch { continue }
    }
    return null
  } catch { return null }
}

# Start the dev server
npm run dev

# Hit a protected endpoint without payment
curl -i http://localhost:8787/api/search?q=test

# Expected response:
# HTTP/1.1 402 Payment Required
# X-PAYMENT-NETWORK: base
# X-PAYMENT-TOKEN: USDC
# X-PAYMENT-ADDRESS: 0xYourWalletAddress
# X-PAYMENT-AMOUNT: 3000
# X-PAYMENT-DECIMALS: 6
# Content-Type: application/json
#
# {
#   "error": "payment_required",
#   "amount": "0.003",
#   "currency": "USDC",
#   "description": "SERP search query",
#   "expires_in": 300,
#   "x402Version": 2,
#   "networks": {
#     "base": {
#       "address": "0xYourBaseAddress",
#       "usdcContract": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
#       "chainId": 8453,
#       "estimatedFee": "<$0.01",
#       "estimatedFinality": "~2s"
#     },
#     "solana": {
#       "address": "YourSolanaPublicKey",
#       "usdcMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
#       "estimatedFee": "<$0.001",
#       "estimatedFinality": "~400ms"
#     }
#   },
#   "paymentRequirements": [...]
# }

# Simulate a request WITH payment proof (using a real Base tx hash)
curl -i http://localhost:8787/api/search?q=test \
  -H "X-PAYMENT-PROOF: 0xabc123...your_tx_hash" \
  -H "X-PAYMENT-NETWORK: base"

# If the tx verifies successfully:
# HTTP/1.1 200 OK
# Content-Type: application/json
#
# {
#   "query": "test",
#   "results": [...],
#   "payment": {
#     "tx_hash": "0xabc123...",
#     "amount": "0.003000",
#     "network": "base"
#   }
# }

# If verification fails:
# HTTP/1.1 400 Bad Request
# {
#   "error": "payment_verification_failed",
#   "network": "base"
# }

# wrangler.toml
name = "my-paid-api"
main = "src/index.ts"
compatibility_date = "2024-12-01"
compatibility_flags = ["nodejs_compat"]

[vars]
# Non-secret configuration
BASE_RPC_URL = "https://mainnet.base.org"
SOLANA_RPC_URL = "https://api.mainnet-beta.solana.com"

# Secrets (set via wrangler secret put)
# WALLET_ADDRESS
# BASE_WALLET_ADDRESS
# SOLANA_WALLET_ADDRESS

# Set wallet addresses as secrets (not checked into source)
wrangler secret put BASE_WALLET_ADDRESS
# Enter: 0xYourBaseWalletAddress

wrangler secret put SOLANA_WALLET_ADDRESS
# Enter: YourSolanaPublicKey

# Deploy to production
wrangler deploy

# Output:
# Uploaded my-paid-api (2.34 sec)
# Published my-paid-api (0.47 sec)
#   https://my-paid-api.your-subdomain.workers.dev

npm install @hono/node-server

// src/node-server.ts
import { serve } from '@hono/node-server'
import app from './index'

// Load environment variables
process.env.BASE_WALLET_ADDRESS = process.env.BASE_WALLET_ADDRESS || ''
process.env.SOLANA_WALLET_ADDRESS = process.env.SOLANA_WALLET_ADDRESS || ''

const port = parseInt(process.env.PORT || '3000')

serve({
  fetch: app.fetch,
  port,
})

console.log(`x402-enabled API running on http://localhost:${port}`)
console.log('Protected endpoints:')
console.log('  GET /api/search?q=...     ($0.003/query)')
console.log('  GET /api/premium-data     ($0.05/request)')
console.log('  POST /api/bulk-export     ($0.50/export)')

# Run with Node.js
npx tsx src/node-server.ts

# Or add to package.json scripts:
# "start:node": "tsx src/node-server.ts"

# Deploy to any Node.js host: Railway, Render, Fly.io, VPS, etc.

// src/routes/serp.ts
// Full SERP scraping API with x402 payment gating + Proxies.sx mobile proxies
import { Hono } from 'hono'
import { x402DualMiddleware } from '../middleware/x402-dual'

type Bindings = {
  BASE_WALLET_ADDRESS: string
  SOLANA_WALLET_ADDRESS: string
  BASE_RPC_URL: string
  SOLANA_RPC_URL: string
  PROXY_HOST: string      // e.g., "us-4g.proxies.sx"
  PROXY_PORT: string      // e.g., "5057"
  PROXY_USER: string      // Proxies.sx username
  PROXY_PASS: string      // Proxies.sx password
}

const serp = new Hono<{ Bindings: Bindings }>()

// Discovery endpoint: describe the API and pricing
serp.get('/serp', (c) => {
  return c.json({
    service: 'SERP Scraping API',
    version: '1.0.0',
    pricing: {
      '/serp/search': {
        method: 'GET',
        cost: '$0.003 USDC per query',
        params: {
          q: 'Search query (required)',
          num: 'Number of results (1-20, default 10)',
          gl: 'Country code (us, uk, de, etc.)',
        },
      },
    },
    networks: ['base', 'solana'],
    protocol: 'x402',
    docs: 'https://proxies.sx/blog/build-paid-api-x402-usdc-tutorial',
  })
})

// x402-protected search endpoint: $0.003 per query
serp.get(
  '/serp/search',
  x402DualMiddleware('0.003', 'SERP search query - real-time results via mobile proxy'),
  async (c) => {
    const query = c.req.query('q')
    if (!query) {
      return c.json({ error: 'Missing required parameter: q' }, 400)
    }

    const num = Math.min(parseInt(c.req.query('num') || '10'), 20)
    const gl = c.req.query('gl') || 'us'
    const payment = c.get('payment')

    try {
      // Build the search URL
      const searchUrl = new URL('https://www.google.com/search')
      searchUrl.searchParams.set('q', query)
      searchUrl.searchParams.set('num', num.toString())
      searchUrl.searchParams.set('gl', gl)
      searchUrl.searchParams.set('hl', 'en')

      // Fetch through Proxies.sx mobile proxy (SOCKS5)
      // In Cloudflare Workers, use the fetch API with proxy config
      // For Node.js, use undici or node-fetch with proxy-agent
      const proxyUrl = `http://${c.env.PROXY_USER}:${c.env.PROXY_PASS}@${c.env.PROXY_HOST}:${c.env.PROXY_PORT}`

      const response = await fetch(searchUrl.toString(), {
        headers: {
          'User-Agent':
            'Mozilla/5.0 (Linux; Android 14; Pixel 8 Pro) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Mobile Safari/537.36',
          'Accept-Language': 'en-US,en;q=0.9',
          Accept:
            'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        },
        // @ts-expect-error - Proxy support varies by runtime
        agent: createProxyAgent(proxyUrl),
      })

      if (!response.ok) {
        return c.json(
          {
            error: 'scrape_failed',
            status: response.status,
            message: 'Search engine returned non-200 status',
          },
          502
        )
      }

      const html = await response.text()

      // Parse search results from HTML
      const results = parseSearchResults(html, num)

      return c.json({
        query,
        country: gl,
        results_count: results.length,
        results,
        scraped_at: new Date().toISOString(),
        proxy: {
          type: '4g_mobile',
          country: gl.toUpperCase(),
          provider: 'proxies.sx',
        },
        payment: {
          tx_hash: payment.txHash,
          amount: payment.amount,
          network: payment.network,
          currency: payment.currency,
        },
      })
    } catch (error) {
      return c.json(
        {
          error: 'internal_error',
          message: error instanceof Error ? error.message : 'Unknown error',
        },
        500
      )
    }
  }
)

/**
 * Parse Google search results from raw HTML.
 * In production, use a proper HTML parser like cheerio.
 */
function parseSearchResults(
  html: string,
  maxResults: number
): Array<{ position: number; title: string; url: string; snippet: string }> {
  const results: Array<{
    position: number
    title: string
    url: string
    snippet: string
  }> = []

  // Simple regex-based extraction (use cheerio in production)
  const linkPattern = /<a href="\/url\?q=([^"&]+)[^"]*"[^>]*>.*?<h3[^>]*>(.*?)<\/h3>/gs
  let match
  let position = 1

  while (
    (match = linkPattern.exec(html)) !== null &&
    results.length < maxResults
  ) {
    const url = decodeURIComponent(match[1])
    const title = match[2].replace(/<[^>]*>/g, '') // Strip HTML tags

    if (url.startsWith('http')) {
      results.push({
        position,
        title,
        url,
        snippet: '', // Extract from adjacent div in production
      })
      position++
    }
  }

  return results
}

export default serp

// src/index.ts (updated)
import { Hono } from 'hono'
import { cors } from 'hono/cors'
import serp from './routes/serp'

const app = new Hono()

app.use('*', cors())

// Health check
app.get('/', (c) => c.json({ status: 'running', x402: true }))

// Mount the SERP scraping API
app.route('/api', serp)

// x402 discovery endpoint (well-known)
app.get('/.well-known/x402.json', (c) => {
  return c.json({
    x402Version: 2,
    seller: {
      name: 'My Paid API',
      description: 'SERP scraping API with mobile proxy support',
      url: 'https://my-paid-api.workers.dev',
    },
    endpoints: [
      {
        path: '/api/serp/search',
        method: 'GET',
        price: '0.003',
        currency: 'USDC',
        networks: ['base', 'solana'],
        description: 'Search engine results via mobile proxy',
      },
    ],
    marketplace: 'https://agents.proxies.sx/marketplace/',
  })
})

export default app

# 1. Discover pricing
curl http://localhost:8787/api/serp
# {
#   "service": "SERP Scraping API",
#   "pricing": {
#     "/serp/search": { "cost": "$0.003 USDC per query" }
#   },
#   "networks": ["base", "solana"],
#   "protocol": "x402"
# }

# 2. Try to search without payment
curl -i "http://localhost:8787/api/serp/search?q=best+mobile+proxies"
# HTTP/1.1 402 Payment Required
# {"error":"payment_required","amount":"0.003","currency":"USDC",...}

# 3. Check the well-known x402 discovery endpoint
curl http://localhost:8787/.well-known/x402.json
# { "x402Version": 2, "endpoints": [...] }

# 4. An AI agent discovers this API, pays $0.003 USDC on Base,
#    and retries with the payment proof header.
#    The server verifies, scrapes via Proxies.sx mobile proxy,
#    and returns structured SERP data.

my-paid-api/
  src/
    index.ts                    # Main app + route mounting
    node-server.ts              # Node.js entry (optional)
    middleware/
      x402.ts                   # Single-network x402 middleware
      x402-dual.ts              # Dual-network (Base + Solana)
      solana-verify.ts          # Solana payment verification
    routes/
      serp.ts                   # SERP scraping API
  wrangler.toml                 # Cloudflare Workers config
  package.json
  tsconfig.json