CONCEPT Cited by 3 sources

Machine payment

Definition

A machine payment is a payment made by an agent directly to a service, programmatically, during task execution — without a human buyer's checkout moment. Distinguished from agentic commerce, which preserves a human buyer whose money the agent is moving; machine payments are agent-to-agent or agent-to-API charges where the agent's own budget settles per-request for tools, data access, or task completion.

Stripe's 2026-03-12 retrospective canonicalises the term: "We're starting to see agents pay other services directly, per request, while they're completing a task. That's outside the standard ACP flow. It's not a checkout session with shipping, loyalty, and a human confirmation step. It's typically a fast, programmatic payment inside an HTTP call."

Architectural shape

Four properties distinguish machine payments from traditional checkout:

1. HTTP-native. The payment is part of an API call's request/response cycle, not a separate session flow. x402's HTTP 402 is the canonical mechanism: server returns 402 Payment Required with pricing, client (the agent) sends payment, server returns 200 OK with the resource.
2. Low latency. Agents "may make thousands of small decisions a day" — checkout-session latency is disqualifying; payment must complete in the same roundtrip as the underlying task.
3. Pay-per-call / pay-per-task granularity. Charges are small and frequent, not large and infrequent. Economics favour micropayment rails (stablecoin settlement) over card-network rails.
4. No human confirmation. By definition the agent is acting within a budget, not asking a human to click "Pay."

Canonical use cases (2026-03-12 Stripe disclosure)

• Per API call: inventory checks, pricing lookups, delivery quotes, pick-up-slot holds.
• Per task: fitment checks, bundle building, quote generation, replenishment orders.

Implementation rail (2026-03-12 preview)

Stripe's implementation is PaymentIntents + stablecoin settlement: agent hits the seller's API, seller calls PaymentIntents with amount + currency, Stripe generates a per-transaction deposit address, seller returns the address to the agent, agent pays programmatically. Initial rail: USDC on Base. "More protocols coming."

x402 passes the deposit address back to the agent via the 402 Payment Required response headers — so an x402 + PaymentIntents composition gives the agent everything it needs in the same HTTP exchange.

Seen in

• sources/2026-04-29-stripe-giving-agents-the-ability-to-pay — positions machine-payment protocols explicitly as "still gaining adoption" while Link's wallet for agents bridges the gap by letting agents pay on existing card + SPT rails. The launch post links to Stripe's Machine Payments Protocol (MPP) at stripe.com/blog/machine-payments-protocol (not yet ingested; distinct from x402 but sibling on the machine-payment altitude). Canonicalises the bridge-to-existing-rails-until-MPP-matures posture: wallet-for-agents fills the near-term agentic-commerce gap; MPP / x402 / stablecoin rails scale separately for machine-native per-call payments.
• sources/2026-03-12-stripe-10-things-we-learned-building-for-the-first-generation-of-agentic-commerce — canonical Stripe framing + initial rail disclosure.
• sources/2026-04-30-cloudflare-agents-can-now-create-cloudflare-accounts-buy-domains-and-deploy — situates machine payments as one of three distinct agent-initiated money-movement shapes. Machine payments (agent → API, per-request) are distinguished from agent-provisioning (user → service provider, subscription / resource lifetime). Different failure modes, different bounding primitives (rate-limit + per-call-price for machine payments vs. monthly spend cap for agent-provisioning).

Related

• concepts/agentic-commerce — sibling concept: human-buyer → agent → seller checkout. Machine payments are the agent → API (no human) slice.
• concepts/agent-provisioned-account — sibling primitive for the agent-provisioning altitude.
• concepts/agent-payment-budget-cap — agent-provisioning's bounding primitive.
• concepts/payment-token-over-credit-card-sharing — shared principle across all three agent-money-movement altitudes.
• systems/x402-protocol — open HTTP 402 standard for Internet-native agent payments; the machine-payment rail.
• systems/stripe-paymentintents-api — Stripe's API extended to accept amount + currency and return a per-transaction deposit address.
• systems/stripe-projects — Stripe's orchestrator for the sibling agent-provisioning altitude.
• patterns/machine-native-per-request-payment — the architectural pattern this concept instantiates.
• patterns/agent-provisioning-protocol — the sibling protocol shape for the agent-provisioning altitude.
• companies/stripe — the vendor driving the first production machine-payment rail on top of x402 + USDC-on-Base.
• companies/cloudflare.