# AI Agent Checkout in Magento 2: Claude Places a Real Order via MCP

> Watch a Claude AI agent place a real Magento 2 order via MCP  -  product search, cart, shipping, checkout. No browser automation. Open-source module demo.

Source: https://angeo.dev/ai-agent-checkout-in-magento-2-claude-places-a-real-order-via-mcp/
Updated: 2026-10-09

AI agents can already *find* products. But can they actually *buy* them  -  placing a real order in a live Magento 2 store, without browser automation or scraping? With `angeo/module-mcp-checkout` v1.0.0, the answer is yes. This post shows you the full flow, step by step, including a real `order_number` from a live demo store.

## Watch the full checkout flow

## How it works: architecture

```
User (Claude.ai)
      v
  MCP Client
      v
Magento MCP Endpoint  <-  Bearer auth + rate limiter
      v
Magento Service Layer
      v
  Quote / Cart
      v
    Order [yes]
```

## MCP call sequence

Every checkout runs the following tool sequence. Each call maps directly to a Magento service layer operation  -  no browser, no session, no cookies.

```
Claude
  v
search_products()         -  find product by keyword
  v
get_product()             -  verify SKU, price, stock
  v
create_cart()             -  open guest cart, get cart_id
  v
add_to_cart()             -  add item by child SKU
  v
get_shipping_methods()    -  estimate delivery options
  v
set_shipping_information()  -  apply address + method
  v
[User confirms total]
  v
place_order()             -  submit cart -> order_number
```

`angeo/module-mcp-checkout` exposes these as six MCP tools over a JSON-RPC endpoint, giving AI agents a structured, authenticated interface to complete a full guest checkout:

- `create_cart`  -  opens a new guest cart

- `add_to_cart`  -  adds a product by SKU

- `get_cart`  -  reads current items and totals

- `get_shipping_methods`  -  estimates available delivery options

- `set_shipping_information`  -  sets address, email, and chosen method

- `place_order`  -  submits the order after user confirmation

No browser automation, no scraping. The agent talks directly to your Magento backend through a secure, rate-limited MCP endpoint.

## Security

- [yes] **Bearer Authentication**  -  every MCP request requires a valid Bearer token; unauthenticated calls are rejected at the endpoint level

- [yes] **Rate limiting**  -  configurable request throttling prevents abuse and protects store performance

- [yes] **Magento ACL**  -  MCP tools operate within Magento's standard Access Control Layer; no privilege escalation is possible

- [yes] **HTTPS only**  -  the MCP endpoint is served exclusively over TLS; plain HTTP is not supported

- [yes] **User confirmation before order placement**  -  `place_order` is never called autonomously; the agent always presents a full order summary and waits for explicit approval

- [yes] **Configurable agent order limit**  -  merchants can set a maximum order value for agent-placed orders in the Magento admin

## Live demo: Claude finds a backpack and buys it

The following is a real session run against [demo.angeo.dev](https://demo.angeo.dev). The prompt: *"I want to buy a Fusion Backpack."*

### Step 1  -  Product discovery

Claude called `search_products`, then `get_product` on the result. It identified the **Fusion Backpack** (SKU: `24-MB02`) as in-stock at $59.

### Step 2  -  Cart creation and item add

`create_cart` returned a fresh `cart_id`. `add_to_cart` confirmed the item was added: subtotal $59, grand total $59.

### Step 3  -  Shipping estimation

`get_shipping_methods` returned one available method: **Flat Rate  -  Fixed at $10.00**.

### Step 4  -  Address and method set

`set_shipping_information` applied the customer's name, street, postcode, city, country, phone, and email. Final totals confirmed: subtotal $59 + shipping $10 = **$69.00 USD**.

### Step 5  -  User confirms, order placed

The agent presented the full order summary and waited for explicit confirmation. After the user approved, `place_order` submitted the cart:

```
{
  "order_number": "000000005",
  "status": "pending",
  "grand_total": 69,
  "currency": "USD"
}
```

A real order, in a real Magento store, placed entirely by an AI agent through MCP  -  with the user in full control at every step.

## Why this matters for Magento merchants

Agentic commerce is not a future concept  -  it is happening now. Shoppers are already using AI assistants to research and shortlist products. The stores that close the loop by letting agents *complete* a purchase will capture that intent before it leaks to a competitor.

`angeo/module-mcp-checkout` is MIT-licensed and installs via Composer:

```
composer require angeo/module-mcp-checkout
bin/magento module:enable Angeo_McpCheckout
bin/magento setup:upgrade
```

## What about payment  -  does Stripe work?

This is the question everyone asks, and it deserves an honest answer.

MCP agents cannot process card payments directly. Stripe requires a PCI-compliant browser form (Stripe.js / Payment Element) to tokenize card data  -  something fundamentally incompatible with a server-side MCP tool call. This is the same constraint that caused OpenAI to pull their native agentic checkout: collecting card details through an agent violates PCI scope.

`angeo/module-mcp-checkout` sidesteps this by design. The agent places the order with a deferred payment method, setting the order status to `pending`. Payment is then handled separately  -  outside the agent flow  -  in one of three ways:

- **B2B / wholesale:** the merchant sends an invoice after order placement  -  already a standard workflow for many Magento stores.

- **Payment Link:** after `place_order`, the agent generates a Stripe, Mollie, or Adyen Payment Link and returns it to the user to complete in their browser. No PCI exposure, no extra fees beyond standard gateway rates.

- **Store redirect:** the agent hands off to the store's standard checkout page with the cart pre-filled, where the shopper completes payment through the normal payment gateway UI.

There are no additional platform fees  -  only standard gateway transaction fees apply, exactly as in a normal checkout. A dedicated `get_payment_link` tool supporting Stripe, Mollie, and Adyen is planned for v2.0.0.

## Current v1.0.0 scope

- Configurable products are supported via child SKU selection  -  dedicated variant tooling with size/color picker is planned for v2.0.0.

- Guest checkout is the current flow  -  registered customer support is on the roadmap.

- Card payment is not collected by the agent  -  deferred payment or Payment Link handoff is used instead (see above).

- An optional agent order limit can be configured in the admin  -  a merchant-controlled guardrail, not a platform constraint.

## FAQ

 **Can Claude place a real Magento 2 order?**
 Yes. The demo in this post shows a real order (`#000000005`) placed on a live Magento 2 store via MCP, with no browser automation involved.

 **Does MCP support Stripe payments?**
 Not directly  -  and deliberately so. Card tokenization requires a PCI-compliant browser form. The module uses deferred payment with an optional Payment Link handoff (Stripe, Mollie, Adyen), keeping the agent flow outside PCI scope entirely.

 **Is browser automation required?**
 No. The agent communicates with your Magento backend through a JSON-RPC MCP endpoint  -  no headless browser, no Selenium, no scraping, no Playwright.

 **Is Selenium required?**
 No. `angeo/module-mcp-checkout` replaces Selenium-based automation entirely. The agent calls structured MCP tools directly against the Magento service layer  -  faster, more reliable, and easier to maintain than any browser automation approach.

 **Does it work with Playwright?**
 Playwright is not needed and not used. MCP is a purpose-built protocol for AI-to-application communication  -  it is a fundamentally better fit for agentic commerce than browser automation tools like Playwright or Puppeteer.

 **Is MCP faster than browser automation?**
 Yes  -  significantly. Browser automation must load full page renders, wait for JavaScript, and parse DOM elements. MCP calls hit the Magento service layer directly via JSON-RPC, with no rendering overhead. A full checkout sequence typically completes in under 5 seconds.

 **Does this work with Adobe Commerce?**
 Yes. The module is compatible with both Magento Open Source and Adobe Commerce 2.4.x.

 **Does the agent act autonomously without the user knowing?**
 No. `place_order` is only called after explicit user confirmation. The agent presents a full order summary  -  items, totals, address, shipping  -  and waits for approval before submitting.

 **Is guest checkout required?**
 In v1.0.0, yes. Registered customer checkout is on the v2.0.0 roadmap.

## What's next

The v2.0.0 roadmap includes registered customer checkout, a coupon/discount tool, configurable product variant tooling, and a Payment Link tool (Stripe, Mollie, Adyen) for automated payment handoff. If you are running a Magento 2 or Adobe Commerce store and want to be an early tester, [reach out](https://angeo.dev/contact/).

*All tools shown in this post are part of the [angeo.dev](https://angeo.dev) open-source AEO stack for Magento 2. The module is available on GitHub and Packagist  -  follow [angeo.dev](https://angeo.dev) for updates.*

## More on this topic

- [MCP for Magento 2: What an MCP Server Does](https://angeo.dev/magento-mcp-server/)
- [Magento 2 MCP Server Module  -  Free](https://angeo.dev/modules/mcp-server/)
- [MCP Checkout Tools for Magento 2](https://angeo.dev/modules/mcp-checkout/)
- [Magento Agentic Commerce Hub 2026: ACP - UCP - AP2](https://angeo.dev/magento-agentic-commerce-hub/)
- [Agentic Commerce for Magento: 12 Merchant Questions Answered](https://angeo.dev/agentic-commerce-magento-questions/)
- [Claude Commerce Agents on Magento 2](https://angeo.dev/claude-commerce-agents-magento/)