Agentic Commerce Protocols: ACP, AP2, x402 Explained

The AI economy needs a common language for commerce. When agents from different platforms want to transact—with merchants, with each other, across payment rails—they need standardized protocols that define identity, authorization, and settlement. ACP, AP2, and x402 are the three competing and complementary standards emerging to fill this gap.

These protocols operate at different layers of the payment stack. Rather than choosing one over the others, the future of agentic commerce may involve all three working together: AP2 for consent and authorization, ACP for checkout coordination, and x402 for payment execution.

What Are Agentic Commerce Protocols?

Agentic commerce protocols are open standards that enable AI agents to discover merchants, authorize transactions, and execute payments autonomously. They solve three fundamental problems: identity (proving the agent is authorized to spend), discovery (finding merchants that accept agent payments), and settlement (moving money securely).

Unlike traditional payment APIs that are proprietary to specific platforms, agentic protocols are designed as open standards that any platform can implement. This interoperability is essential—in a world where agents from OpenAI, Google, Anthropic, and countless startups need to transact, proprietary silos would be economically crippling.

ACP (Agentic Commerce Protocol)

ACP (Agentic Commerce Protocol) is an open standard co-developed by OpenAI and Stripe that enables AI agents to safely participate in commercial transactions. ACP powers ChatGPT's Instant Checkout feature and represents the "card network" approach to agentic commerce—leveraging existing payment infrastructure while adding an AI-native protocol layer.

How ACP Works

ACP uses Shared Payment Tokens—a new payment primitive designed specifically for agentic systems. When a user enrolls in ACP, their payment credentials are tokenized once. Agents can then use these tokens to transact with any ACP-integrated merchant without exposing card numbers or requiring per-transaction approval.

The protocol includes a merchant registry where businesses integrate once to accept payments from any ACP-enabled agent. This "integrate once, support all agents" model mirrors how PCI compliance works for traditional card payments.

ACP Technical Specifications

Strengths and Limitations

Strengths: ACP benefits from Stripe's existing merchant network, making it immediately useful for businesses that already process Stripe payments. The protocol is optimized for conversational retail experiences where agents interact with merchants on behalf of users in real-time.

Limitations: ACP relies on legacy card rails, which means it inherits the limitations of traditional payment networks—including settlement delays, interchange fees, and geographic restrictions. The protocol is also tightly coupled to Stripe's infrastructure, which may limit adoption by platforms that compete with Stripe.

Key Use Cases

• Conversational commerce: ChatGPT's Instant Checkout for retail purchases

• Subscription management: Agents managing recurring payments

• Card-based transactions: Use cases where traditional payment methods are preferred

AP2 (Agent Payments Protocol)

AP2 (Agent Payments Protocol) is an open protocol developed by Google in collaboration with Coinbase and over 60 organizations, launched in September 2025. AP2 operates at a different layer than ACP—focusing on agent discovery, authorization, and task delegation rather than just payment execution.

How AP2 Works

AP2 provides the overall framework for agentic transactions with step-by-step traceability. When multiple agents collaborate on a task, AP2 handles the delegation chain—tracking which agent authorized which action, which agents sub-contracted to which other agents, and where consent was obtained.

The protocol includes clear consent mechanisms that let users define exactly what their agents are allowed to do. Unlike ACP's focus on checkout, AP2 focuses on the orchestration layer—the workflow that happens before, during, and after payment.

AP2 Technical Specifications

Strengths and Limitations

Strengths: AP2 is platform-agnostic—not tied to Stripe, OpenAI, or any single provider. The collaborative development model (60+ organizations) suggests broader ecosystem support. AP2's focus on cross-agent workflows makes it well-suited for complex, multi-agent scenarios.

Limitations: AP2 is newer (launched September 2025) and less proven in production than ACP. The protocol focuses on orchestration rather than settlement, meaning it typically needs to be paired with another protocol (like ACP or x402) for actual money movement.

Key Use Cases

• Multi-agent workflows: Coordinating multiple specialized agents

• Cross-platform transactions: Agents from different platforms working together

• Complex consent scenarios: Transactions requiring multi-step approval chains

x402 Protocol

x402 is an open payment standard developed by Coinbase that enables internet-native payments, with a specific focus on AI agent transactions. Built on HTTP, x402 revives the HTTP 402 "Payment Required" status code originally proposed in the 1990s but never widely adopted.

How x402 Works

x402 is payment-native—it focuses entirely on moving money, particularly using stablecoins like USDC for instant settlement. The protocol is designed for pay-per-use models and micropayments that are economically unviable with traditional payment rails.

When an agent needs to pay for something using x402, the protocol negotiates payment directly between agent and merchant without requiring API keys, accounts, or subscriptions. This makes x402 particularly well-suited for agent-to-agent (A2A) commerce where AI agents pay each other for services.

x402 Technical Specifications

Strengths and Limitations

Strengths: x402 enables instant settlement via stablecoins, avoiding the delays and fees of card networks. The pay-per-use model aligns perfectly with AI agent economics—agents pay for what they use, not via subscriptions. The no-API-key approach reduces friction for agent-to-agent transactions.

Limitations: x402 requires both parties to support crypto/stablecoins, which limits merchant adoption compared to card-based protocols. The protocol is tightly coupled to Coinbase's infrastructure, raising questions about long-term neutrality.

Key Use Cases

• Agent-to-agent payments: AI agents paying each other for services

• Micropayments: Transactions too small for traditional payment rails

• Pay-per-use AI: Charging per successful task rather than per API call

How the Protocols Work Together

The three protocols are complementary rather than competing—they operate at different layers of the payment stack and can be combined within a single transaction.

Layered Architecture

┌─────────────────────────────────────────┐
│         Application Layer               │
│    (Agent decides what to buy)          │
├─────────────────────────────────────────┤
│           AP2 Layer                     │
│   (Consent, delegation, orchestration)  │
├─────────────────────────────────────────┤
│           ACP Layer                     │
│  (Merchant discovery, checkout coord)   │
├─────────────────────────────────────────┤
│          x402 Layer                     │
│      (Payment execution, settlement)    │
└─────────────────────────────────────────┘

┌─────────────────────────────────────────┐
│         Application Layer               │
│    (Agent decides what to buy)          │
├─────────────────────────────────────────┤
│           AP2 Layer                     │
│   (Consent, delegation, orchestration)  │
├─────────────────────────────────────────┤
│           ACP Layer                     │
│  (Merchant discovery, checkout coord)   │
├─────────────────────────────────────────┤
│          x402 Layer                     │
│      (Payment execution, settlement)    │
└─────────────────────────────────────────┘

┌─────────────────────────────────────────┐
│         Application Layer               │
│    (Agent decides what to buy)          │
├─────────────────────────────────────────┤
│           AP2 Layer                     │
│   (Consent, delegation, orchestration)  │
├─────────────────────────────────────────┤
│           ACP Layer                     │
│  (Merchant discovery, checkout coord)   │
├─────────────────────────────────────────┤
│          x402 Layer                     │
│      (Payment execution, settlement)    │
└─────────────────────────────────────────┘

Example Transaction Flow

A single agentic purchase might use all three protocols:

1. AP2: User's agent delegates shopping task to a specialist agent; AP2 tracks the delegation chain and obtains consent

2. ACP: Specialist agent discovers ACP-integrated merchants and coordinates checkout

3. x402: Payment executes via stablecoin for instant settlement

This layered approach lets each protocol focus on what it does best rather than trying to solve every problem.

Protocol Comparison

Implementation Considerations

For Merchants

If you're a business considering which protocol(s) to support:

• Start with ACP if you already use Stripe—integration is minimal and you gain access to ChatGPT's user base

• Add AP2 if you want to support multi-agent workflows and cross-platform compatibility

• Consider x402 if you serve tech-savvy customers comfortable with stablecoins, or if you sell to other AI agents

For Agent Developers

If you're building AI agents:

• ACP provides the easiest path to real-commerce transactions if your agents interact with retail merchants

• AP2 is essential if your agents collaborate with other agents or need to delegate tasks

• x402 is optimal if your agents perform micropayments or transact with other AI agents

For Platform Builders

If you're building an AI platform or agent infrastructure:

• AP2's open, collaborative model makes it attractive for avoiding vendor lock-in

• ACP's Stripe integration provides immediate commercial viability

• x402's crypto-native approach offers autonomy from traditional finance

How Anyway Supports These Protocols

Anyway integrates with ACP and x402 protocols, providing the billing and monetization layer that sits on top of agentic payment infrastructure. While protocols handle the mechanics of moving money, Anyway handles the business logic—tracking costs, measuring outcomes, and enabling pricing models.

Anyway stands out because it adds an outcome-based monetization layer to agentic protocols. Protocols move money; Anyway connects money to value—enabling pricing based on successful task completion rather than payment execution. This closed-loop approach combines agent observability (tracking what agents actually accomplish) with billing infrastructure (charging for those accomplishments).

The Future of Agentic Protocols

The agentic protocol landscape is in early stages. ACP has first-mover advantage through Stripe's merchant network. AP2 has momentum through broad industry collaboration. x402 has technical purity through its crypto-native design.

The most likely outcome isn't a single winner—but protocol convergence where ACP, AP2, and x402 each specialize in their layer while interoperating at the boundaries. The platforms that succeed will be those that abstract away protocol complexity, letting merchants accept agent payments and developers build agent commerce without needing to become protocol experts.

Agentic Protocols FAQ

Do I need to choose between ACP, AP2, and x402?

No. These protocols operate at different layers and can work together. AP2 handles orchestration and consent, ACP handles merchant discovery and checkout, and x402 handles payment execution. A single transaction might use all three.

Which protocol should I implement first?

For most merchants, ACP is the starting point because it integrates with Stripe's existing merchant network. For agent developers, AP2 provides the most flexibility for cross-platform workflows. For agent-to-agent payments, x402 is the most practical choice.

Are these protocols open source?

Yes. All three protocols have open-source implementations: ACP and AP2 have GitHub repositories, and x402's code is available on Coinbase's GitHub. This open approach is designed to encourage broad adoption.

What happens if a protocol fails or shuts down?

Because these protocols are open standards, multiple implementations can exist. If one company's implementation fails, the protocol itself can continue through other implementations. This is similar to how email (SMTP) survived the demise of individual email providers.

Can I accept agent payments without implementing these protocols?

You can accept agent payments through traditional APIs, but you'll miss out on interoperability benefits. Agents from other platforms won't be able to discover your business or transact seamlessly. The protocols provide the "common language" that makes agent commerce scale.

How do these protocols relate to traditional payment methods?

ACP and x402 ultimately settle through traditional or crypto payment rails—ACP through card networks (via Stripe) and x402 through stablecoins on blockchains. The protocols sit on top of these rails, adding AI-native features like agent identity, consent management, and discovery.