Ievgenii Gryshkun

Posted on Jul 9 • Originally published at angeo.dev

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

#magento #ai #php #webdev

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?

I built angeo/module-mcp-checkout to answer that, and the short version is: yes. This post walks through the full flow, the architecture, and the one problem everyone asks about — payments.

Watch the full checkout flow

How it works: architecture

User (Claude.ai)
      ↓
  MCP Client
      ↓
Magento MCP Endpoint  ←  Bearer auth + rate limiter
      ↓
Magento Service Layer
      ↓
  Quote / Cart
      ↓
    Order ✓

MCP call sequence

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

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

The module exposes these as six MCP tools over a JSON-RPC endpoint:

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 the Magento backend through a secure, rate-limited MCP endpoint.

Security

✅ Bearer Authentication — every MCP request requires a valid Bearer token
✅ Rate limiting — configurable throttling protects store performance
✅ Magento ACL — MCP tools operate within Magento's standard Access Control Layer
✅ HTTPS only — the endpoint is served exclusively over TLS
✅ User confirmation before order placement — place_order is never called autonomously
✅ Configurable agent order limit — merchants set a max order value in admin

Live demo: Claude finds a backpack and buys it

Real session against demo.angeo.dev. The prompt: "I want to buy a Fusion Backpack."

Step 1 — Product discovery. Claude called search_products, then get_product. It identified the Fusion Backpack (SKU: 24-MB02), in-stock at $59.

Step 2 — Cart. create_cart returned a fresh cart_id. add_to_cart confirmed the item — subtotal $59.

Step 3 — Shipping. get_shipping_methods returned Flat Rate — Fixed at $10.

Step 4 — Address. set_shipping_information applied name, street, postcode, city, country, phone, email. Total: $69.

Step 5 — Confirm & place. After explicit user confirmation, 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 control at every step.

The payment problem

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

MCP agents can't process card payments directly. Card tokenization requires a PCI-compliant browser form (Stripe.js / Payment Element) — fundamentally incompatible with a server-side MCP tool call. This is the same constraint that killed OpenAI's native agentic checkout: collecting card details through an agent violates PCI scope.

My approach sidesteps this by design. The agent places the order with a deferred payment method (status pending). Payment happens separately:

B2B / wholesale: merchant invoices after order placement — already standard for many stores
Payment Link: the agent generates a Stripe / Mollie / Adyen payment link for the human to complete in-browser. No PCI exposure.
Store redirect: hand off to the store's normal checkout page with the cart pre-filled

No extra platform fees — only standard gateway rates apply. A dedicated get_payment_link tool (Stripe, Mollie, Adyen) is planned for v2.0.0.

Current v1.0.0 scope

Configurable products via child SKU selection — variant tooling coming in v2.0.0
Guest checkout only for now — registered customer support on the roadmap
Card payment handled via deferred payment / payment link handoff
Optional agent order limit configurable in admin

FAQ

Is browser automation required? No. JSON-RPC MCP endpoint — no headless browser, no Selenium, no Playwright.

Is MCP faster than browser automation? Significantly. No page rendering, no DOM parsing. A full checkout completes in under 5 seconds.

Does this work with Adobe Commerce? Yes — Magento Open Source and Adobe Commerce 2.4.x.

Does the agent act autonomously? No. place_order only fires after explicit user confirmation.

Install

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

MIT-licensed, part of the open-source angeo.dev Agentic Readiness Suite for Magento 2.

Disclosure: I built this module. It's open-source MIT. Genuinely curious what other Magento devs think about agentic checkout as a direction — happy to answer anything about the architecture or MCP tool design in the comments.

DEV Community