npm init -y
npm install express @gameflow/x402-server

# Or clone starter
git clone https://github.com/gameflow-labs/x402-express-starter
cd x402-express-starter

# Production Environment
NODE_ENV=production

# Payment Configuration  
FACILITATOR_URL=https://facilitator.gameflowlabs.com/api
X402_PAY_TO=0x1234...abcd (Your wallet address)
X402_NETWORK=base (Preferred chain: base, solana, polygon, etc)

# API Keys (if using external data)
KALSHI_API_KEY=your_api_key
OPENAI_API_KEY=your_openai_key

const express = require('express');
const { x402Middleware } = require('@gameflow/x402-server');

const app = express();

// Apply x402 to all /api/* routes
app.use('/api/*', x402Middleware({
  payTo: process.env.X402_PAY_TO,
  facilitatorUrl: process.env.FACILITATOR_URL,
  network: process.env.X402_NETWORK || 'base',
  price: 0.001 // $0.001 per API call
}));

// Protected endpoint
app.get('/api/prediction', (req, res) => {
  res.json({
    player: req.query.player,
    prediction: "Will score 2+ goals",
    confidence: 0.87,
    kalshi_odds: 3.2,
    edge_detected: true,
    x402_paid: true
  });
});

// Health check
app.get('/health', (req, res) => {
  res.json({ status: 'ok' });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`x402 server listening on ${PORT}`);
});

node index.js

pip install x402-python

poetry add x402-python

from fastapi import FastAPI, Request
from x402 import X402Middleware, require_payment

app = FastAPI()

# Initialize x402 middleware
x402 = X402Middleware(
    pay_to="0x1234...abcd",
    facilitator_url="https://facilitator.gameflowlabs.com/api",
    network="base"
)

@app.get("/api/predict")
@require_payment(price=0.001)
async def predict(player: str):
    return {
        "player": player,
        "prediction": "2+ goals",
        "confidence": 0.92,
        "kalshi_odds": 2.8,
        "x402_validated": True
    }

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

from flask import Flask, jsonify
from x402 import X402Client, require_payment

app = Flask(__name__)

x402 = X402Client(
    pay_to="0x1234...abcd",
    network="base"
)

@app.route("/api/data")
@require_payment(price=0.001)
def get_data():
    return jsonify({
        "data": "Paid fantasy data",
        "status": "x402 validated"
    })

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

# .env
X402_PAY_TO=0x1234...abcd  # Your wallet address to receive payments
X402_NETWORK=base  # Network: base, solana, polygon, bsc, sei, peaq
FACILITATOR_URL=https://facilitator.gameflowlabs.com/api

# For advanced use
X402_MIN_AMOUNT=0.0001  # Minimum payment amount
X402_TIMEOUT=30  # Seconds to wait for payment confirmation

@app.get("/api/predict")
@require_payment(calculate_price_func=lambda request: {
    'basic': 0.001,
    'premium': 0.01,
    'enterprise': 0.1
}.get(request.query_params.get('tier'), 0.001))
async def predict_custom_price(tier: str, player: str):
    # Dynamic x402 pricing based on tier for AI agents
    return generate_prediction(player, tier)

# Accept fantasy predictions payments on multiple chains
@app.get("/api/multi-network")
@require_payment(
    networks=['base', 'solana', 'polygon'],
    price=0.001
)
async def multi_network_endpoint():
    return {"message": "Paid on any supported network"}

npm install @gameflow/x402-client

import { X402Client } from '@gameflow/x402-client';

const client = new X402Client({
  signer: wallet, // ethers.js wallet signer
  network: 'base'
});

// Make paid request - x402 payment happens automatically
const data = await client.get('https://api.example.com/predictions');
console.log(data);

// AI agent submitting x402-protected prediction requests
const response = await client.post('https://api.example.com/bet', {
  player: 'Haaland',
  market: 'goals',
  amount: 100
});

import { X402Provider, useX402 } from '@gameflow/x402-react';

function App() {
  return (
    <X402Provider network="base" signer={wallet}>
      <MyComponent />
    </X402Provider>
  );
}

function MyComponent() {
  const { client } = useX402();
  
  const fetchData = async () => {
    const data = await client.get('/api/predictions');
    // x402 payment handled automatically for AI agents
  };
}

pip install x402-client

from x402_client import X402Client

# Initialize client with wallet for AI agent x402 payments
client = X402Client(
    private_key="0x...",
    network="base"
)

# Make x402 paid request - payment automatic
response = client.get('https://api.example.com/predictions')
print(response.json())

import asyncio
from x402_client import AsyncX402Client

async def main():
    client = AsyncX402Client(
        private_key="0x...",
        network="base"
    )
    
    # Multiple concurrent x402 paid requests for AI agent
    results = await asyncio.gather(
        client.get('https://api1.example.com/data'),
        client.get('https://api2.example.com/predictions'),
        client.get('https://api3.example.com/odds')
    )

asyncio.run(main())

const client = new X402Client({
  signer: wallet,
  network: 'base'  // base | solana | polygon | bsc | sei | peaq
});

const client = new X402Client({
  signer: wallet,
  network: 'base',
  maxPayment: 0.01,  // Max $0.01 per request - AI agent safety
  confirmationThreshold: 1  // Blocks to wait for x402 confirmation
});

// Add custom GameFlow API headers for AI agents
const data = await client.get('/api/data', {
  headers: {
    'X-API-Version': '2',
    'X-Agent-Type': 'claude-sonnet'
  }
});

try {
  const data = await client.get('/api/predictions');
} catch (error) {
  if (error.code === 'INSUFFICIENT_BALANCE') {
    // AI agent wallet lacks funds for x402 payment
    console.log('Top up your wallet to continue');
  }
  
  if (error.code === 'PAYMENT_REJECTED') {
    // x402 transaction failed on-chain
    console.log('Payment was not accepted');
  }
  
  if (error.code === 'NETWORK_ERROR') {
    // Blockchain RPC issue for x402 transaction
    console.log('Network connectivity problem');
  }
}

x402Middleware({
  payTo: string,           // Your wallet address to receive payments
  price: number,           // Price per request in dollars (e.g., 0.001)
  network: string,         // base | solana | polygon | bsc | sei | peaq
  facilitatorUrl: string,  // Optional: Custom facilitator endpoint
  requiredHeaders: string[] // Optional: Additional headers required
})

app.use('/api/*', x402Middleware({
  payTo: '0x1234...abcd',
  price: 0.001,
  network: 'base',
  facilitatorUrl: 'https://facilitator.gameflowlabs.com/api'
}));

@require_payment(
  price: float,                    # Price in dollars per AI agent request
  pay_to: Optional[str],           # Override default wallet address
  networks: Optional[List[str]]    # Accepted networks for x402
)

@app.get("/api/data")
@require_payment(price=0.001)
async def get_predictions():
    return {"data": "paid fantasy predictions"}

new X402Client({
  signer: Signer,              // ethers.js wallet or private key
  network: string,             // Preferred payment network
  maxPayment: number,          // Max amount willing to pay per request
  retries: number              // Number of payment retry attempts
})

// Make GET request with automatic x402 payment
client.get(url: string, options?: RequestOptions)

// Make POST request with x402 payment for AI agents
client.post(url: string, data: any, options?: RequestOptions)

// Make PUT request
client.put(url: string, data: any, options?: RequestOptions)

// Make DELETE request  
client.delete(url: string, options?: RequestOptions)

{
  "txHash": "0xfade...",
  "network": "base",
  "expectedRecipient": "0x1234...",
  "expectedAmount": "1000000", // in smallest unit (e.g. wei)
  "expectedToken": "0xusdc..."
}

{
  "valid": true,
  "verified": true,
  "hash": "0xfade...",
  "from": "0xabcd...",
  "to": "0x1234...",
  "amount": "1000000",
  "timestamp": 1698234567
}

X-Accept-Payment: base, solana, polygon

X-Payment-Required: true

X-Payment-Network: base

X-Payment-Address: 0x1234...abcd

X-Payment-Amount: 0.001

X-Payment-Hash: 0xfade...1234

X-Payment-Proof: test-signature-abc123

X-Facilitator-URL: https://facilitator.gameflowlabs.com/verify

# Production Environment
NODE_ENV=production

# x402 Payment Configuration  
FACILITATOR_URL=https://facilitator.gameflowlabs.com/api
X402_PAY_TO=0x1234...abcd  # Your wallet for AI agent payments
X402_NETWORK=base  # base | solana | polygon | bsc

# API Keys for GameFlow data
KALSHI_API_KEY=your_kalshi_key
OPENAI_API_KEY=your_openai_key

# Facilitator
FACILITATOR_API_KEY=https://facilitator.gameflowlabs.com/api

# Network RPC (optional for custom nodes)
BASE_RPC_URL=https://base.llamarpc.com
SOLANA_RPC_URL=https://api.mainnet-beta.solana.com

FROM node:18-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --production

COPY . .

ENV NODE_ENV=production
ENV PORT=3000

EXPOSE 3000

CMD ["node", "index.js"]

# Build image
docker build -t gameflow-x402 .

# Run container
docker run -p 3000:3000 \
  -e X402_PAY_TO=0x1234...abcd \
  -e X402_NETWORK=base \
  gameflow-x402

// Add logging to track x402 GameFlow AI agent payments
app.use((req, res, next) => {
  console.log({
    timestamp: new Date().toISOString(),
    method: req.method,
    path: req.path,
    paymentHash: req.headers['x-payment-hash'],
    paymentNetwork: req.headers['x-payment-network']
  });
  next();
});