Start accepting Base USDC payments or launch autonomous AI agent billing in less than 5 minutes.

npm install @ownpay/sdk viem

pnpm add @ownpay/sdk viem

yarn add @ownpay/sdk viem

import { OwnPayClient } from '@ownpay/sdk';

const client = new OwnPayClient({
  apiKey: process.env.OWNPAY_API_KEY,
  environment: 'live' // Base Mainnet (8453)
});

const intent = await client.intents.create({
  order_id: 'ORDER-9910',
  amount: 25.00,
  currency: 'USD'
});

console.log('Checkout URL:', intent.checkout_url);

curl -X POST https://ownpaylab.dev/api/v1/intents \
  -H "Authorization: Bearer own_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"order_id":"ORDER-9910","amount":25.00,"currency":"USD"}'

from ownpay import OwnPayClient

client = OwnPayClient(api_key="own_live_YOUR_KEY")
intent = client.intents.create(order_id="ORDER-9910", amount=25.00, currency="USD")
print("Checkout URL:", intent["checkout_url"])

Understanding how Human Retail Commerce and Autonomous Agent Micropayments converge into a single cryptographic settlement core.

Cryptographic Settlement Invariant

Both rails log every transaction into OwnPay's double-entry accounting ledger where:

Connect your AI coding assistant (Cursor, Claude Code, Windsurf, Copilot) directly to OwnPay using the open Model Context Protocol (MCP) server integration (active development).

MCP Server Configuration

{
  "mcpServers": {
    "ownpay": {
      "command": "npx",
      "args": ["-y", "@ownpay/mcp-server@latest"],
      "env": {
        "OWNPAY_API_KEY": "own_live_YOUR_API_KEY",
        "BASE_CHAIN_ID": "8453"
      }
    }
  }
}

Create non-custodial checkout sessions that accept local fiat currencies and settle automatically into native Base USDC.

Creating an Intent via REST API

const intent = await client.intents.create({
  order_id: 'INV-8820',
  amount: 5000,
  currency: 'BDT', // Converted to USDC automatically
  customer_email: 'buyer@example.com'
});

curl -X POST https://ownpaylab.dev/api/v1/intents \
  -H "Authorization: Bearer own_live_KEY" \
  -H "Content-Type: application/json" \
  -d '{"order_id":"INV-8820","amount":5000,"currency":"BDT"}'

Generate zero-code shareable payment links for social commerce, invoices, and digital downloads.

Payment links can be generated dynamically via the dashboard or API. When buyers visit an ownpaylab.tech/pay link, they get an instant mobile-optimized checkout UI with QR codes and Coinbase Smart Wallet support.

https://ownpaylab.tech/pay?to=0xYourMerchantAddress&amount=25.00¤cy=USD&title=Pro+SaaS+Plan

Real-time localized fiat conversion into Base USDC with slippage protection and Purchasing Power Parity (PPP).

Zero subscription ($0/mo, $0/yr). True Pay-As-You-Go with tailored compliance requirements to eliminate regulatory friction across all countries.

Sponsor transaction gas fees on Base so end-users never have to hold ETH to make purchases.

curl -X POST https://ownpaylab.dev/api/v1/paymaster/sponsor \
  -H "Content-Type: application/json" \
  -d '{
    "sender": "0xUserSmartAccountAddress",
    "target": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "value": "15000000"
  }'

The native HTTP status code standard for machine-to-machine micropayments. Monetize high-value APIs, AI inference tokens, and live data feeds with sub-cent settlement on Base.

Client-Side Autonomous Handshake (SDK)

import { OwnPayAgentClient } from '@ownpay/sdk';

const agent = new OwnPayAgentClient({
  agentId: 'agent_alpha_99',
  apiKey: process.env.OWNPAY_AGENT_KEY,
  chain: 'base'
});

// Automatically intercepts HTTP 402, pays USDC, and returns JSON payload
const data = await agent.fetchWithX402('https://ownpaylab.dev/api/v1/x402/data-feed');
console.log('Premium Feed Data:', data);

Enterprise risk mitigation ensuring autonomous agents operate safely within pre-allocated budgets, recipient whitelists, and human escalation thresholds.

Immutable, mathematically balanced accounting journal recording every inbound checkout and outbound agent payment with on-chain settlement proofs.

Querying the Ledger API

curl https://ownpaylab.dev/v1/ledger \
  -H "Authorization: Bearer own_live_YOUR_KEY" \
  -H "Content-Type: application/json"

Client libraries currently being engineered for TypeScript, Node.js, Python, and Model Context Protocol (MCP).

Receive real-time signed callbacks whenever payments settle on Base Mainnet. Verification engine live; automated retry portal in active development.

import crypto from 'crypto';

app.post('/webhooks/ownpay', express.raw({ type: 'application/json' }), (req, res) => {
  const signature = req.headers['x-ownpay-signature'];
  const timestamp = req.headers['x-ownpay-timestamp'];
  
  const expected = crypto
    .createHmac('sha256', process.env.OWNPAY_WEBHOOK_SECRET)
    .update(`v1:${timestamp}:${req.body}`)
    .digest('hex');

  if (signature !== `v1=${expected}`) {
    return res.status(401).send('Invalid signature');
  }

  // Fulfill merchant order
  res.json({ received: true });
});

Learn how to create hosted payment intents and handle real-time callbacks in modern Next.js 14 applications.

1. Server Action (app/actions/checkout.ts)

'use server';
import { OwnPayClient } from '@ownpay/sdk';

const client = new OwnPayClient({ apiKey: process.env.OWNPAY_API_KEY });

export async function createCheckoutSession(orderId: string, amount: number) {
  const intent = await client.intents.create({
    order_id: orderId,
    amount,
    currency: 'USD'
  });
  return intent.checkout_url;
}

Integrate x402 automated micropayments into autonomous Python AI agents using LangChain tools.

from langchain.tools import tool
from ownpay import OwnPayAgentClient

agent = OwnPayAgentClient(agent_id="scout_01", api_key="own_agent_KEY")

@tool
def procure_premium_market_data(query: str) -> dict:
    """Fetches paid data via x402 micropayment on Base."""
    return agent.fetch_with_x402("https://ownpaylab.dev/api/v1/x402/data-feed")

Implement dynamic EIP-681 QR codes on retail tablets and physical checkout terminals.

In physical retail stores, cashiers punch in the fiat amount (e.g. 500 BDT or $15 USD). The OwnPay engine generates an instant EIP-681 URI displayed on a customer-facing screen. Customers scan with Coinbase Smart Wallet, Binance Web3, or MetaMask and confirm in under 2 seconds.

How to configure the EIP-4337 Paymaster so retail shoppers never need ETH in their wallets.

Traditional Web3 checkouts require users to hold both the settlement token (USDC) and native gas tokens (ETH). OwnPay's Paymaster inspects incoming UserOperations and sponsors 100% of the gas, allowing buyers with 0.00 ETH to complete transactions seamlessly.

OwnPay APIs adhere to RESTful conventions. All requests must be authenticated via Bearer API keys over HTTPS.

Authorization: Bearer own_live_YOUR_MERCHANT_KEY
Content-Type: application/json

Provision a non-custodial smart account and assign risk policy boundaries to an AI agent.

{
  "name": "Data Procurement Agent",
  "framework": "LangChain",
  "policy": {
    "maxPerTx": 50.00,
    "maxDaily": 500.00,
    "escalationThreshold": 200.00
  }
}

Dispatches on-chain payment with automatic routing to Level 1 autonomous clearance, Level 2 policy checks, or Level 3 human review.

List all pending Level 3 human approval requests awaiting merchant signature or Telegram authorization.

Extract verified double-entry accounting records with Base block inclusion hashes.

Initiate merchant checkout sessions with currency conversion from BDT, USD, EUR, INR.

Request gas sponsorship for buyer ERC-20 transfer UserOperations.

Pay-per-request monetized endpoint requiring HTTP 402 challenge response.

Connect OwnPay's sub-cent Base USDC gateway to your e-commerce storefront with zero custom code (Q4 2026 milestone).

Equip your autonomous AI agents with wallets, budget limits, and x402 payment actions.

Allow AI coding tools to inspect endpoints, generate checkout forms, and test sandbox intents via MCP.

Passkey biometric checkout enabling consumers to pay in 1 tap without seed phrases.

Launched: September 2026

• 7-Slide Interactive Institutional Presentation: Full confidential executive brief and investor data room.
• Institutional Terminology Overhaul: Refined labels across dashboard and docs to Silicon Valley venture standards.
• Mintlify 5-Tab Navigation System: Docs, Guides, API Reference, Integrations, and Changelog switcher.
• In-Page Command Palette: Ctrl+K instant search filtering across 30+ protocol guides and APIs.

Launched: August 2026

• HTTP 402 (x402 Protocol): Autonomous pay-per-API stream integration.
• 3-Tier Policy Engine: Level 1 Auto, Level 2 Policy, Level 3 Human Review.
• Double-Entry Ledger: Invariant Total Debits === Total Credits.

Launched: July 2026

• Base Mainnet (8453) Core: Sub-cent USDC settlement engine.
• Merchant Operating System: Real-time intent monitoring and hosted links.
• Dual Sandbox: Base Sepolia simulation with test faucets.