PayBots. Payment rails for autonomous software.

The problem

The payment stack ends where autonomous software begins.

Cards were built for humans

Chargebacks, fraud review, and monthly statements assume a person on both sides of every transaction. An autonomous agent has no wallet to reach for and no signature to give.

Agents transact in milliseconds and micro-amounts

An agent negotiates, buys, and settles thousands of times an hour, often for fractions of a cent. Card networks flag that behavior as fraud and price it out of existence.

Every API call is a payment event

Compute, tokens, bandwidth, and data rows all carry a unit cost. Legacy rails cannot price a request worth a tenth of a cent, so that value moves on invoices weeks later.

How it works

Three moving parts. One settlement layer.

Issue a spending identity

Give an agent its own payment identity with programmable limits. Per call, per hour, per counterparty, per category. The rules live in the rail, so the agent cannot overspend.

Pay per call

The agent settles each request over instant rails at the moment of use. A quote arrives, funds move, and the response unlocks inside the same round trip.

Audit everything

The owner audits every satoshi and dollar in a real-time ledger. Each entry carries the counterparty, the quote, the receipt, and the exact request it paid for.

The 402 flow

HTTP reserved 402 Payment Required in 1997. PayBots gives it a job.

A metered endpoint quotes a price, the agent settles inside its programmed limits, and the retry carries proof of payment. The whole loop completes in a single request cycle, with every hop recorded on the ledger.

agent-payment.js

import { PayBots } from "@paybots/agent";

// A spending identity with hard limits, issued by the agent's owner
const wallet = new PayBots({
  token: process.env.PAYBOTS_AGENT_TOKEN,
  limits: { perCall: "0.01 USD", perDay: "25.00 USD" },
});

// 1. Call a metered endpoint
let res = await fetch("https://api.vendor.com/v1/inference", {
  method: "POST",
  headers: { Authorization: "Bearer " + wallet.token },
  body: JSON.stringify({ prompt }),
});

// 2. The vendor prices this request and responds 402 Payment Required
if (res.status === 402) {
  const quote = await res.json();
  // { amount: "0.00042", currency: "USD", quote_id: "qt_8f3a" }

  // 3. Settle instantly, inside the wallet's programmed limits
  const receipt = await wallet.pay(quote);

  // 4. Retry with proof of payment
  res = await fetch("https://api.vendor.com/v1/inference", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + wallet.token,
      "PayBots-Receipt": receipt.id,
    },
    body: JSON.stringify({ prompt }),
  });
}

const data = await res.json(); // paid, metered, on the ledger

Use cases

Machine-speed commerce shows up everywhere agents do.

API monetization

Price every endpoint per call. Agents pay at request time, revenue settles instantly, and the billing portal disappears from the stack.

Agent-to-agent commerce

Agents hire other agents. A research agent pays a scraping agent per page and a summarization agent per token, all on one ledger.

Compute marketplaces

GPU minutes, sandbox seconds, and inference batches get priced and settled at the moment of use. Idle capacity becomes a market.

Data licensing

Datasets earn per row and per query. Owners set the price once and the ledger records every read by every agent.

Get on the rails early.

PayBots is pre-launch. Join the waitlist for build updates and first access when the rails open.