How to Settle USDC Agent Payments with Catena ACK-Pay (2026)

AI agents can hold USDC and call APIs. The missing piece for production commerce is a shared pattern for identity, payment requests, settlement, and cryptographically verifiable receipts that both sides can audit.

This guide shows how to settle USDC agent payments with Catena ACK-Pay, the payments half of Catena Labs' open-source Agent Commerce Kit (ACK), using ACK-ID for identity, ACK-Lab patterns for rules and wallets, and a PaymentReceiptCredential as proof of settlement.

Facts below come from the ACK-Pay introduction, Payment Request payload, Receipt Verification, ACK-ID introduction, Catena's ACK-Lab developer preview, the agentcommercekit/ack GitHub repo, and the @agentcommercekit/ack-pay TypeScript SDK (ACK version 2025-05-04) as of September 28, 2026. No invented fees, mainnet volumes, or partner lists beyond those sources. ACK-Lab's hosted developer preview has closed; the open ACK protocols and SDK remain available for self-hosted experiments.

Key Takeaways

• Catena ACK-Pay is the ACK payment protocol for agent USDC settlement with verifiable receipts.
• Pair ACK-ID DIDs and credentials before any payment request so both agents prove who they represent.
• Build a signed Payment Request with USDC options (for example Base eip155:8453), then settle via a Payment Service.
• Verify a PaymentReceiptCredential (W3C VC) before unlocking the paid resource or marking the invoice paid.
• ACK-Lab demos used testUSD and policy rules; production means your own Payment Service, Receipt Service, and spend limits.

What this guide covers

You will define the named objects, set prerequisites, walk identity → rules → payment request → settle → receipt, run a worked USDC example on Base, compare ACK-Pay vs bare x402 vs Circle Agent Stack, then close with FAQ and next steps.

What Catena ACK-Pay is (and is not)

ACK-Pay is Catena Labs' open Agent Commerce Kit payment protocol. It standardizes how agents initiate payment requirements, execute through a Payment Service, and prove settlement with a cryptographically signed ACK receipt (a W3C Verifiable Credential of type PaymentReceiptCredential).

Per Catena's ACK docs, ACK-Pay works alongside network-specific agent payment programs (for example Visa Intelligent Commerce and Mastercard Agent Pay) and alongside stablecoin-oriented 402 flows such as Coinbase x402, l402, and h402. It does not replace USDC itself. Settlement still happens on a settlement network you choose in each payment option (Base, Solana, card rails, and others appear as examples in the payload docs).

ACK-ID is the companion identity protocol: decentralized identifiers (DIDs) and Verifiable Credentials that link an agent to the human or organization that owns it. ACK-Pay can run alone, but Catena documents stronger authentication when ACK-ID is bound into the flow.

ACK-Lab was Catena's hosted developer preview that packaged ACK-ID identity credentials, testnet wallets funded with testUSD (a stablecoin proxy), and policy Rules that capped spend. Catena's blog states the preview has closed; the underlying ACK protocols stay open source at agentcommercekit.com and on GitHub.

As of September 28, 2026, DefiLlama lists USDC circulating supply near $75.2 billion (DefiLlama stablecoins API). That scale is why agent settlement guides fix on USDC rather than inventing a new dollar token.

How to Pay for an x402 API with Coinbase AgentKit (2026)

Buyer-side x402 + AgentKit path when you only need HTTP 402 USDC micropayments, not full ACK-Pay receipts.

Stablecoin Insider

Prerequisites

Before you settle USDC with Catena ACK-Pay patterns:

• Node.js 22+ and pnpm (ACK quickstart), plus a clone of agentcommercekit/ack.
• A buyer agent wallet that can hold USDC (or testUSD on testnet) on your chosen network. For Base USDC agent wallets, see How to Create a Coinbase Agentic Wallet for USDC and How to Create a Circle Agent Wallet for USDC.
• A seller (server) agent that can issue a signed Payment Request and verify receipts.
• Either a Payment Service + Receipt Service you operate, or a third-party service that speaks ACK-Pay (Catena demos used hosted ACK-Lab; that preview is closed).
• Spend policies: per-tx and daily caps, allowed assets (USDC), and allowed counterparties. ACK-Lab's demos blocked over-limit swaps when Rules were tight.
• Optional but recommended: ACK-ID credentials for both agents so identity is checked before money moves. See also How to Verify an AI Agent Before Accepting USDC.

Step 1: Identity with ACK-ID

Start with identity, not the transfer. ACK-ID answers who the agent is and which principal is liable.

Typical builder path from Catena's ACK-ID docs and demos:

• Create or resolve a DID for the agent (examples in the ecosystem include did:web, did:pkh, and did:key).
• Issue a Verifiable Credential that binds the agent DID to the operating principal (company or person), with permissions and constraints your compliance program requires.
• Exchange credentials before commerce. Catena's ACK-Lab swap and marketplace demos had agents verify cryptographic credentials before negotiating price or sending payment tokens.
• Cache the verified principal graph for the session so every later Payment Request is attributed to a known controller.

If either side fails credential verification or hits a revoked credential, stop. Do not open an ACK-Pay session.

Step 2: Set rules and wallets

ACK-Lab exposed three capabilities Catena still treats as the practical ACK stack: Identity, Wallet, and Rules.

On the wallet side, fund the buyer agent with USDC (mainnet) or testUSD (testnet demos). Keep seller settlement addresses out of the client when a Payment Service sits in the middle; the Payment Request's recipient field points at the pay-in identity the Payment Service expects.

On the rules side, encode at least:

• Max per-transaction amount (for example 10 USDC for API credits).
• Daily spend cap.
• Allowed currencies (USDC) and networks (for example Base eip155:8453).
• Allowed merchant or counterparty DIDs.

Catena's marketplace demo let agents negotiate price only inside those policy bounds. When a rule blocked a trade, the demos failed closed instead of quiet overspend. For funding workflows after identity is live, see How to Fund an AI Agent Wallet with USDC.

Step 3: Build the Payment Request

ACK-Pay centers on a JSON Payment Request plus a signed paymentRequestToken.

Server-initiated sequence (paywalled API or content): the server agent builds the request after the client asks for a paid resource, often delivered as HTTP 402 when HTTP is the transport, or over A2A / WebSocket when it is not.

Client-initiated sequence (invoice, checkout, known obligation): the client agent constructs the same payload shape, often with help from a Payment Service API.

Core fields from Catena's payload docs:

With the TypeScript SDK (@agentcommercekit/ack-pay), builders use helpers such as createPaymentRequestBody to attach a signed token from the server issuer DID and keypair. Keep private keys in secrets managers; never ship them inside agent prompts.

Step 4: Settle USDC via the Payment Service

The client agent selects a USDC payment option, contacts the listed Payment Service, and completes settlement on the named network.

Catena's components docs describe the Payment Service as the intermediary that can route across networks, convert assets, run risk or compliance checks (often with ACK-ID), manage human approval, and coordinate with a Receipt Service. The same docs note a Payment Service can also expose an x402 facilitator interface for servers that already speak x402. That is the bridge between ACK-Pay's receipt model and the thinner HTTP 402 micropayment path covered in How to Choose an x402 Facilitator for USDC and How to Enable Circle x402 Facilitator for USDC.

Builder checklist for USDC settlement:

• Verify the Payment Service identity before sending funds.
• Confirm the selected option's currency is USDC, decimals are 6, and amount matches the quote.
• Execute the transfer through the Payment Service (or an embedded payment path the service defines).
• Wait for settlement confirmation on the network before treating the invoice as paid.
• Receive the signed ACK receipt from the Receipt Service (sometimes the same operator as the Payment Service).

Step 5: Verify the PaymentReceiptCredential

The unlock step is receipt verification, not a raw chain explorer glance.

Catena's receipt docs define an ACK Receipt as a W3C Verifiable Credential with type array including PaymentReceiptCredential. The credential subject typically carries the payer DID, the original paymentRequestToken, the paymentOptionId used, and metadata such as amount, currency, decimals, recipient, and settlement timestamp (optional settlement tx hash in metadata).

Server verification order from the docs:

• Validate the VC signature against the Receipt Service issuer DID.
• Confirm the issuer is on your trusted Receipt Service allowlist.
• Check revocation status.
• Match payment details: token, option id, recipient, amount/currency/decimals, freshness against policy.

SDK helpers include createPaymentReceipt, verifyPaymentReceipt, and getReceiptClaimVerifier. Persist the VC next to your internal invoice id for audit.

Worked example: 10 USDC premium API credits on Base

Scenario: a research agent needs 100 credits from a data API server agent. The server requires 10 USDC on Base before returning the payload.

• Identity. Both agents present ACK-ID credentials. The server resolves the buyer's DID and confirms the principal is an approved research org.
• Rules. Buyer policy allows USDC on Base, max 25 USDC per tx, 100 USDC daily. Seller policy accepts USDC Base only for this SKU.
• Payment Request. Server builds a request id req_premium_100, description "Premium API access (100 credits)", expiry in 15 minutes, and one payment option: currency USDC, network eip155:8453, amount 10000000 (10 USDC at 6 decimals), recipient set to the Payment Service pay-in, plus paymentService and receiptService URLs. It signs paymentRequestToken with its issuer key.
• Settle. Buyer selects the USDC Base option, pays through the Payment Service, and receives a PaymentReceiptCredential.
• Unlock. Buyer retries the API call with the receipt. Server runs verifyPaymentReceipt, confirms 10 USDC and the matching request token, then returns the credits. Both sides store the VC and any settlement reference in metadata.

That same shape covers Catena's documented swap and data-marketplace demos: credential exchange, policy-bound negotiation, ACK-Pay processing, then access or swap completion with an audit trail.

// Illustrative Payment Request option (from ACK-Pay payload docs shape)
{
  "id": "usdc-base",
  "currency": "USDC",
  "network": "eip155:8453",
  "amount": 10000000,
  "decimals": 6,
  "recipient": "eip155:8453:0xPaymentServicePayIn",
  "paymentService": "https://payments.example.com/base",
  "receiptService": "https://receipts.example.com/base"
}

ACK-Pay vs x402-only vs Circle Agent Stack

Stablecoin Insider's comparison for product engineers choosing a settlement path in 2026:

For Circle-native nanopayment how-tos on this site, see How to Make a Circle Agent Nanopayment in USDC.

FAQ

This content is provided for informational and educational purposes only and does not constitute financial, investment, legal, or tax advice; no material herein should be interpreted as a recommendation, endorsement, or solicitation to buy or sell any financial instrument, and readers should conduct their own independent research or consult a qualified professional.