---
title: "Pay-Per-Call APIs: $0.005 Calls, Measured Treasury Costs"
description: "Sub-cent API calls clear the card fee floor and settle at request; measured USDC off-ramp sweeps show deterministic treasury costs for pay-per-call revenue."
author: "Hugues Clouâtre"
pubDatetime: 2026-11-04T23:59:00.000Z
modDatetime: 2026-11-05T06:03:08.000Z
url: https://clouatre.ca/posts/pay-per-call-margins-treasury/
tags:
  - "agentic-ai"
  - "ai-governance"
  - "case-studies"
---

Twelve sealed off-ramp conversions, sized from $1 to $100, measured the treasury question directly: converting USDC, a dollar-pegged stablecoin, to fiat cost exactly the advertised rate on two independent rails, $0.00 on the issuer rail and the quoted 0.20% on the exchange. Every figure is traceable to on-chain transfer hashes or exchange records ([Clouatre, 2026](https://doi.org/10.5281/zenodo.23927458)).

Pay-per-call APIs change the profit-and-loss (P&L) mechanics of a digital business in three places: unit economics, revenue recognition, and treasury. Card rails charge a fixed fee per transaction, usually in the tens of cents, which makes a sub-cent charge structurally unprofitable. The x402 protocol ([Coinbase Developer Platform, 2025](https://www.x402.org/x402-whitepaper.pdf)) identifies this fixed-cost floor as the reason machine-scale micropayments never worked on card infrastructure; settlement over a layer 2 (L2) chain plus a facilitator fee near $0.001 removes it. The treasury change is the hardest, and the sweeps above are its evidence; the engineering of the payment stack is covered in [x402 on Cloudflare Workers](/posts/agent-payments-x402), and this post stays on the finance side of that boundary.

## Why Does the Fee Floor Matter for Unit Economics?

The fee floor is the largest single line in a pay-per-call P&L, and it splits cleanly into the problem and the arithmetic.

### Why Sub-Cent Prices Fail on Cards

The floor decides which price points can exist. A card transaction priced at $0.005 loses roughly $0.29 before the product delivers anything. No amount of volume fixes a negative unit margin at the transaction level, so card-based platforms are pushed toward subscriptions, minimum charges, or prepaid balances. Each of those adds friction that an autonomous agent has no way to clear.

### The $0.005 Arithmetic on x402

The x402 model prices differently. A deployment on this site sells a resume evaluation at $0.005 gross, and the hosted facilitator charges $0.001 per settlement while covering the gas. The margin on a five-dollar monthly subscription is a percentage calculation. The margin on a half-cent call is an arithmetic fact: gross $0.005, facilitator $0.001, network cost covered by the facilitator.

Figure 1 shows the two fixed fees side by side.

**Fixed fee per call: the card floor dwarfs the facilitator fee**

| Series | Value |
| --- | --- |
| Card fixed fee (typical) | 30 cents |
| x402 facilitator fee | 0.1 cents |

*Figure 1: Fixed per-call fee at a $0.005 price point. The card floor exceeds the price itself by roughly 60x; the facilitator fee leaves $0.004 of payment contribution per call.*

That arithmetic holds at one call and at one million calls, which is the structural difference. Fixed per-call fees do not scale with price, so removing them does not improve margins on large transactions. Their removal makes small transactions possible at all. Table 1 carries the worked numbers.

*Table 1: Per-call unit economics at a $0.005 price point: the card fixed fee exceeds the price by roughly 60x, while the facilitator fee leaves $0.004 of payment contribution before compute. Card-fee anchor: Stripe's published US standard rate, 2.9% plus a $0.30 fixed component ([Stripe, 2026](https://stripe.com/pricing)).*

| Cost component | Card rail | x402 rail |
| --- | --- | --- |
| Fixed per-transaction fee | Roughly $0.30 typical | $0.001 facilitator, covers gas |
| Variable network cost | Billed to the merchant | Covered by the facilitator |
| Payment contribution at a $0.005 price | Roughly -$0.295 per call | $0.004 per call, before compute |

## How Does Settlement Change Revenue Mechanics?

Settlement-at-request replaces the invoice cycle. Under net-30 terms, a business books revenue, waits a month or more for cash, and manages collections. Under pay-per-call settlement, the payment confirms before the response is delivered. Days sales outstanding for this revenue line is effectively zero, and there is no receivables ledger to maintain.

Each settlement also produces the raw material of the revenue ledger. The payment response names the payer, the transaction hash, and the network, which is everything a ledger entry needs at the moment revenue is recognized.

*Code Snippet 1: Settlement receipt from the live deployment, abridged; the full receipt appears in the deployment post.*

```json file="PAYMENT-RESPONSE header (decoded, abridged)"
{
  "success": true,
  "payer": "0x…",
  "transaction": "0xddc212d834162a7642341310de13d573e99796a22ae390042e3dca4f7b57bf39",
  "network": "eip155:8453"
}
```

### What Replaces the Chargeback?

The absence of chargebacks is usually presented as pure margin expansion, and that framing oversells it. A chargeback is a dispute-resolution mechanism. When an automated agent pays and receives a failed or malformed response, the default `exact` scheme has no protocol-level refund path. The newer `auth-capture` scheme adds a facilitator-gated refund lifecycle ([x402 Foundation, 2026](https://github.com/x402-foundation/x402/blob/main/specs/schemes/auth-capture/scheme_auth_capture.md)), and refundable commerce schemes remain on the roadmap. Refunds in x402 are therefore immature and intermediated, not automatic, and none of this changes the operator-side arithmetic.

The dispute friction has moved from the card network to the operator. An operator must either build off-protocol credit handling, absorb the support load, or both. The engineering consequence sits in the timeout window: if an agent pays and the response is lost in transit, a retry without an idempotency key tied to the transaction hash pays twice for one call. The treasury experiments hit a milder version of this failure: a convert committed twice for lack of a persisted idempotency token, double-charging principal at zero fee. Converged industry practice on refund and replay handling does not yet exist, so the honest planning assumption is that refund policy is an unbuilt product surface, not a saved fee.

## What Does Treasury Operations Actually Cost?

Treasury is the least-documented cost of adopting pay-per-call revenue, so it deserves observed numbers rather than estimates. A site earning USDC holds a stablecoin on an L2. Converting that stablecoin to spendable fiat is the off-ramp, and the operator's treasury experiments priced it directly at pay-per-call scale ([Clouatre, 2026](https://doi.org/10.5281/zenodo.23927458)).

### What the Sweep Experiments Measured

*Table 2: Measured off-ramp conversion is deterministic at micro scale: issuer rail 1\:1 with $0.00 fee on every tranche; exchange rail exactly the quoted 0.20% taker fee (v1 = issuer-rail pass; v2 = exchange-replication pass).*

| Rail | Measured outcome |
| --- | --- |
| Issuer (Coinbase convert) | 1\:1 conversion, $0.00 fee on all tranches; 8 executed v1 tranches totaling $157.26, reproduced on 2 v2 converts |
| Independent exchange (Kraken) | Exactly the quoted 0.20% taker fee; $0.20196 realized on the v2 pass's 101 USDC working capital |
| Fiat-off-ramp gateways | Dexter has no operator fiat off-ramp; Transak quoted $10 USDC to $5.86, about 41 percent effective cost, Ethereum-only with card payout |

The headline finding is cost determinism: on both rails, off-ramp cost at micro volume equals the advertised rate. The issuer rail converted 1\:1 with a $0.00 fee on every tranche, and the exchange charged exactly its quoted 0.20% on both executed sell orders, landing within a pre-registered budget of $1. The protocol was sealed in version control before execution: one pass, no tranche re-run on unfavorable outcomes, every figure traceable to Kraken query identifiers and the public repository.

The two rails are not a controlled comparison; one is issuer redemption and the other is an order-book sale on different inputs. The order-book fills were benign: 0.005 percent above the observed mid, realized slippage marginally better than the quoted ask. The defensible claim is narrower and more useful: there is no price discovery to do. Industry guides commonly quote 0.5 to 1 percent for stablecoin-to-fiat conversion ([DECTA, 2024](https://www.decta.com/company/media/crypto-on-ramps-and-off-ramps)); the observed endpoints sit below that range because a deterministic issuer or exchange path beats the generic bundled service.

### Where the Sweep Design Failed

The open work is scheduling and design, not price. The experiments measured one conversion pass per tranche, so sweep cadence and repeated-cycle costs remain unmeasured. Latency from send to spendable fiat was recorded in three clean observations between 5 seconds and 4 minutes 23 seconds on the issuer rail, where spendable means the exchange's USD ledger, not bank delivery. Three points support no service-level claim, and the v2 pass was recovery-assisted throughout, so it supports none at all. Figure 2 renders the three points with that caveat attached.

**Send-to-spendable fiat latency: three clean observations, in seconds**

| Series | Issuer rail, v1 |
| --- | --- |
| Send-to-spendable (seconds) mean | 168 (observed range, n=3: 5-263) |

- Send-to-spendable (seconds) observations 1/1 (n=3): 5, 236, 263

*Figure 2: The three clean send-to-spendable observations from the v1 sweep pass, in seconds (5 s, 3 m 56 s, and 4 m 23 s = 263 s). Three points support no service-level claim; the mean and observed range are shown for shape only, not as a confidence interval.*

The strongest finding in the v2 pass was a failure. It ordered a fixed-size international disbursement tranche after an automated residue formula, and the formula sold the entire spendable balance first, making the disbursement arithmetically impossible. Code Snippet 2 shows the recorded sequence.

*Code Snippet 2: v2 pass execution sequence from the treasury experiments, abridged; the residue sale drains the balance before the fixed-size Canadian-dollar (CAD) tranche runs.*

```json file="v2 pass execution sequence (abridged)"
{
  "order": [
    "kraken-10",
    "kraken-residue",
    "cad-20",
    "cad-eft",
    "coinbase-5-1",
    "coinbase-5-2"
  ],
  "kraken-10": "sold 10 of 101 USDC",
  "kraken-residue": "sold all 91 remaining USDC",
  "cad-20": "not_executed_below_minimum"
}
```

The two failed CAD rows are recorded outcomes, not missing data, and the repo calls this finding the most reproducible result of the pass. The lesson generalizes beyond this experiment. Disbursement must be ordered within the sweep design, not appended after it.

## What Does Accounting for Micro-Receipts Require?

Every settled call produces a receipt in USDC, and each receipt is income at fair market value at settlement time. Because USDC is dollar-pegged, fair market value is close to face value, which keeps the valuation question simple. The complication is volume and structure.

The later conversion of USDC to fiat is a second disposition of an asset, so each micro-receipt carries a basis that must be tracked until the sweep closes it out. A busy endpoint can generate thousands of receipts per month, and each one is an accounting event. The receipts also arrive continuously, which means the ledger closes in real time rather than on a monthly cycle.

This is an operational cost, not tax advice, and the specific treatment varies by jurisdiction. The operator's practical burden is a ledger that records every settlement, links it to the later sweep, and reconciles the two sides. Code Snippet 1 is the raw input to that ledger, Code Snippet 2 is the pass-level sequence the ledger must reconcile against, and Code Snippet 3 sketches the linkage between a settlement and the sweep that closes its basis.

*Code Snippet 3: Illustrative ledger entry linking one settlement receipt to the sweep tranche that closes its basis.*

```json file="treasury ledger entry (illustrative)"
{
  "settlement": {
    "tx": "0xddc212d8…bf39",
    "usdc_received": "0.005",
    "basis_usd": "0.005"
  },
  "sweep_close": {
    "tranche": "coinbase-5-2",
    "usdc_sold": "5.00",
    "fiat_received": "5.00",
    "fee_usd": "0.00"
  }
}
```

Standard crypto-accounting tooling assumes exchange-scale trades, not five-dollar receipts arriving per request. The gap between those two assumptions is real treasury work that a P&L forecast built only on gross revenue will miss. Any business case for a pay-per-call endpoint should carry a line item for this accounting pipeline alongside the facilitator fee.

## How Big Is Pay-Per-Call Demand Today?

The measured baseline is modest and should anchor any plan. Industry analyses of on-chain x402 activity diverge sharply on how much is genuine. RZLT counts hundreds of millions in transaction volume with roughly half appearing to be testing ([RZLT, 2026](https://www.rzlt.io/blog/agentic-payments-2026-x402-explainer)), while Bitquery's audit finds $2.6 billion settled in a month with 88 percent of the value a single bridging contract on Arbitrum and genuine agent payments totaling roughly $57,000 ([Bitquery, 2026](https://bitquery.io/investigations/x402-ai-agent-payments-audit)). Depending on methodology, the testing share ranges from roughly half to the high nineties. This site's own live traffic shows the same small scale; the priced endpoints are listed in the public x402 discovery manifest ([/.well-known/x402](https://clouatre.ca/.well-known/x402)). Most challenge requests are scanners, and paid conversion sits near 0.4 percent.

The forecasts are a different genre, and honest presentation labels them as such. Table 3 puts the two genres side by side, with each figure attributed to its source.

*Table 3: Measured ecosystem baseline versus published forecasts for agent-driven commerce, by source and status.*

| Claim | Source | Status |
| --- | --- | --- |
| On-chain x402 volume contested: roughly half testing (RZLT) to almost none genuine agent commerce (Bitquery) | RZLT (2026); Bitquery (2026) | Measured baseline, method-dependent |
| $3 trillion to $5 trillion of agent commerce globally by 2030 | McKinsey (2025) | Forecast |
| Agentic payments in the trillions on comparable horizons | Galaxy Research (2026) | Forecast |

A multi-trillion forecast is not a demand plan. The credible grounding is the observed baseline. The rails work at micro scale today, and the gap between today's testing traffic and tomorrow's commerce is unmeasured.

## Where Does x402 Sit Among Payment Protocols?

Payment protocols are consolidating rather than fragmenting. Google's Agent Payments Protocol (AP2) defines mandate and authorization semantics for agent payments, and its public repository includes x402-compatible samples ([Google, 2026](https://github.com/google-agentic-commerce/AP2)). Card networks are building their own agent credentials, with Mastercard's Agent Pay extending network identity to delegated AI purchasers ([Mastercard, 2026](https://www.mastercard.com/global/en/news-and-trends/press/2026/september/new-trust-and-intelligence-services.html)), and Mastercard's Agent Pay for Machines (AP4M), launched June 2026, targets permissioned sub-cent machine settlement directly ([Mastercard, 2026](https://www.mastercard.com/global/en/news-and-trends/press/2026/june/mastercard-launches-agent-pay-for-machines.html)). AP4M narrows the fee-floor gap on card rails, though its credentialing, permissioning, and settlement model still differs from a stateless per-request rail. These services cover trust and mandate. x402 addresses the rail: it moves value at request time without accounts or identity infrastructure. Table 4 summarizes the division of labor.

*Table 4: Payment protocol families by the P&L question each addresses.*

| Protocol family | What it addresses | Example |
| --- | --- | --- |
| Mandate and authorization | Who may spend, within what limits | Agent Payments Protocol (Google, 2026) |
| Network agent credentials | Identity and dispute rails for delegated purchasers | Mastercard Agent Pay (Mastercard, 2026) |
| Machine-native card settlement | Permissioned sub-cent settlement on network rails | Agent Pay for Machines (Mastercard, 2026) |
| Settlement rail | Value moved at request time, no accounts | x402 (Coinbase Developer Platform, 2025) |

The institutional signal matters as much as the feature comparison. The x402 protocol is now governed by the x402 Foundation under the Linux Foundation, with the protocol contributed to neutral stewardship in April 2026 ([Linux Foundation, 2026](https://www.linuxfoundation.org/press/linux-foundation-is-launching-the-x402-foundation-and-welcoming-the-contribution-of-the-x402-protocol)). Foundation governance lowers the adoption risk that a finance leader is actually pricing: the risk that a single vendor changes the rules of the rail. For planning purposes, the protocols look complementary. Expect mandate layers on top of settlement rails, not a winner-take-all standard.

## What Should Executives Budget For?

The fee floor is solved on x402 rails. Sub-cent charges settle today at arithmetic margins; the facilitator fee is $0.001 against a card floor in the tens of cents. Off-ramp cost is measured and deterministic. What remains is overhead the protocol deliberately leaves to the operator: sweep scheduling, basis tracking across thousands of micro-receipts, and disbursement design that orders international payouts inside the sweep rather than after it. The failed CAD tranche in the treasury experiments is the cheapest available tuition on that last point, because it shows the failure mode before any real disbursement depends on it.

For a finance leader evaluating a pay-per-call endpoint, the budget line items are concrete. Revenue arrives at settlement with no receivables cycle, but refund handling remains facilitator-gated. Treasury overhead is small per transaction and nontrivial per month, dominated by accounting pipeline work rather than conversion fees. Demand is measured in testing traffic today and modeled in trillions for 2030, and a plan should be written against the first number.

The deployment post closes with the observation that demand and treasury operations are the business decisions the protocol leaves untouched ([x402 on Cloudflare Workers](/posts/agent-payments-x402)). The treasury half now has observed endpoints. The rest is open work.

## References

- Bitquery, "x402 Protocol: $2.6B a Month Across 5 Chains" (2026) -- https://bitquery.io/investigations/x402-ai-agent-payments-audit
- Clouatre, H., "USDC-to-Fiat Sweep Experiments: x402 Treasury Evidence" (2026) -- https://doi.org/10.5281/zenodo.23927458
- Coinbase Developer Platform, "x402: The Internet Native Payment Protocol" (2025) -- https://www.x402.org/x402-whitepaper.pdf
- DECTA, "Crypto On-Ramps and Off-Ramps" (2024) -- https://www.decta.com/company/media/crypto-on-ramps-and-off-ramps
- Galaxy Research, "Agentic Payments: x402 and AI Agents in the AI Economy" (2026) -- https://www.galaxy.com/insights/research/x402-ai-agents-crypto-payments
- Google, "Agent Payments Protocol (AP2)" (2026) -- https://github.com/google-agentic-commerce/AP2
- Linux Foundation, "Linux Foundation Launches the x402 Foundation" (2026) -- https://www.linuxfoundation.org/press/linux-foundation-is-launching-the-x402-foundation-and-welcoming-the-contribution-of-the-x402-protocol
- Mastercard, "Mastercard Unveils New Trust and Intelligence Services" (2026) -- https://www.mastercard.com/global/en/news-and-trends/press/2026/september/new-trust-and-intelligence-services.html
- Mastercard, "Mastercard Launches Agent Pay for Machines" (2026) -- https://www.mastercard.com/global/en/news-and-trends/press/2026/june/mastercard-launches-agent-pay-for-machines.html
- McKinsey & Company, "The Agentic Commerce Opportunity: How AI Agents Are Ushering in a New Era for Consumers and Merchants" (2025) -- https://www.mckinsey.com/capabilities/quantumblack/our-insights/the-agentic-commerce-opportunity-how-ai-agents-are-ushering-in-a-new-era-for-consumers-and-merchants
- RZLT, "Agentic Payments in 2026: The x402 Explainer" (2026) -- https://www.rzlt.io/blog/agentic-payments-2026-x402-explainer
- Stripe, "Pricing & Fees" (2026) -- https://stripe.com/pricing
- x402 Foundation, "Auth-Capture Scheme Specification" (2026) -- https://github.com/x402-foundation/x402/blob/main/specs/schemes/auth-capture/scheme_auth_capture.md