Skip to main content
Glama

Introducing shopware-mcp

A Shopware 6 shop is about two hundred entities behind one Admin API. Ask an assistant "is everything okay with the shop?" and the honest answer takes seven searches with Criteria filters, three state machines by their technical names, a couple of aggregations, and an OAuth token it must never repeat back to you. Wire a model straight to that API and it gets all of it, including the right to PATCH a price because a prompt said so.

The Model Context Protocol turned "give the model real tools" into a one-line config change. It says nothing about what a good tool for a shop looks like: which of the two hundred entities matter on a Tuesday morning, what "stuck order" means, or that a stock correction should be shown before it is sent.

shopware-mcp is that layer. One small server that speaks MCP to the host and the Admin API to the shop, and knows Shopware well enough to answer in one call what used to take an afternoon in the admin. It also notices when orders stop coming, and tries the checkout the way a customer would to find out why:

Curated tools

Products, orders and their history, documents, customers, categories, promotions, reviews, payment and shipping methods, plugins, stock, sales channels, scheduled tasks, the shop's trading settings: twenty tools that return compact JSON with exact totals, descriptions written for a model, and Shopware's own Criteria filters. No invented query language.

The customer's view

checkout_simulate puts products and codes into a throwaway cart through Shopware's own Store API, as a guest shipping anywhere or as a given customer with their group, prices and rules, and explains every cart error in plain words: a country the channel does not ship to, a code that expired, a payment method hidden by a rule, a parent product that needs a variant, a customer who cannot log in there. storefront_search searches like a customer and says why a product does not show up. Nothing is ordered; the cart is deleted.

A pulse

shop_pulse puts today next to the same hours of the same weekday in recent weeks and weighs the current quiet spell: how many orders those hours usually bring and how likely it is to see none by chance. "No order for six hours, when three to seven always came" is a broken checkout, not a slow Sunday. On a campaign day it compares with the same weekday last year, or with what the day should bring.

Ready for the campaign

promotions_check looks at every promotion that runs or starts before a date, switched on or not, and names what would stop it: inactive at its start, no discount, no channel or only channels in maintenance, no code left, the redemption limit, 60 % that was meant to be 6 %, two automatic discounts that add up. The campaign_ready prompt adds the checkout, stock and the plan for the day.

A watch that says why

shopware-mcp watch looks at orders and payments every few minutes and writes to Slack only when something changes: orders stop, payments fail, the shop stops answering, and when it is back to normal. The alarm comes with the likely cause: shop_diagnose looks at the usual suspects in one go (a storefront in maintenance, a test purchase of the best seller, an extension updated an hour ago, errors in Shopware's log, a stopped worker). Public holidays in the compared weeks are left out of "usual". On Black Friday: --baseline last-year --expect 3.

Synthetic customers

journeys_run walks fixed buying paths through the real cart, "Swiss guest with code SUMMER26", "regular customer pays by invoice", and names the one that broke and why. watch --journeys journeys.json runs them on every look, so a payment method that vanished after a plugin update raises the alarm before the first customer gives up.

Ready for AI shoppers

agent_readiness builds the product feed that AI shopping agents read (the Agentic Commerce feed of OpenAI and Stripe, field for field like Google Merchant) and says what keeps products out: no brand, no image, a GTIN with a wrong check digit, no weight, a storefront without HTTPS or without the privacy, terms and revocation pages an agent checkout links to. shopware-mcp feed --out feed.jsonl writes the whole feed.

Before the next update

update_check asks Shopware's own update service what comes next, which security issues it fixes, and for every extension whether it works with it: compatible, update the extension first, a compatible version announced, or not compatible. For 6.8 and every major after it.

Pages in the chat

In hosts that show MCP Apps (Claude, ChatGPT, VS Code), shop_brief, shop_pulse, shop_audit and sales_report come with an interactive page next to the answer: tiles, charts and findings, in the host's light or dark theme. The model still gets compact JSON.

Hosted, nothing to install

shopware-mcp hosted serves many shops from one address: an assistant adds the URL as a connector, the person connects their shop with an Integration's keys through OAuth, and that is it. Read-only, keys sealed with AES-256-GCM, tokens stored only as hashes. Try it at https://p-h07rka.project.space/mcp.

What a discount costs

promotion_impact replays a discount, or an existing promotion, on the real orders of the last weeks: what it would have cost on every eligible order and at the shop's usual code uptake, and how often a cap kicks in. margin_check finds products sold below their purchase price, thin margins, and what the running automatic discount leaves of them.

An audit

shop_audit runs eighteen checks in one call, plus ready-made rule packs for the GPSR, the accessibility act and shopping feeds, and the shop's own rules from a JSON file of Shopware filters, no code needed: a checkout that went unusually silent, promotions in the next two weeks that will not work, paid orders that never shipped or never got an invoice, unpaid orders going stale, shipped orders never completed, products out of stock, running out at the current sales pace, without a cover, without a delivery time or invisible in every sales channel, promotions past their end date, channels in maintenance, storefronts missing a legal page, reviews waiting for moderation, scheduled tasks that stopped running, extensions with updates waiting, and which EU duties look covered, including whether Shopware itself is set up for ZUGFeRD e-invoices. Prioritised, with samples and a hint per finding. The same audit runs as shopware-mcp audit from cron or CI, no MCP host needed.

Reports and a forecast

sales_report asks Shopware to aggregate: gross, net, average order, revenue per currency and channel, orders per state, a day/week/month timeline, the top products and, on request, the change against the period before. customer_report does the same for people: new accounts, guest share, repeat share, top customers by revenue. stock_forecast turns sales velocity and stock into days of cover, run-out dates and reorder quantities. returns_report says how many orders came back and which products come back most, from Shopware's own delivery states. The figures were checked against SQL on the same database.

An escape hatch

entity_schema describes any of the 200+ entities, a plugin's custom entities included, and entity_search queries them with the same filters and lets Shopware aggregate over the match: orders per payment method, revenue per month, anything a terms, sum or histogram can say. Entities that hold credentials are refused, secrets in the rest are scrubbed.

A brake

Read-only unless you start it with --allow-write. Even then every write is a dry run that shows the exact request first, and a write budget can cap how many real writes a process may make. Ship, mark paid, remind, refund, correct stock, note, generate a document, create a product or a promotion, give a product a picture, moderate a review, update a customer, invoice fifty orders in one go, tag a record: fifteen narrow writes, nothing else. Secrets never appear in output, logs or errors.

Shops are not identical, so the tool list is not either: at startup the server looks up which extensions are installed and registers extra tools for the ones it knows. A plain shop gets the core set. A shop with more plugins gets a bigger agent, without configuration.


Related MCP server: magento-mcp-server

See it work

Six hours without an order, and why. Sunday evening. The pulse compares the silence with the same hours of the last eight Sundays, which always brought three to seven orders, and puts the odds of chance at about one in 170. The agent then tries to buy something the way a customer would and finds the storefront in maintenance mode. Nothing was ordered, nothing changed.

shop_pulse reports an unusual six-hour silence, then checkout_simulate finds the storefront in maintenance mode

The checkout as a customer sees it. A customer in Switzerland says a code does not work. A throwaway cart through Shopware's own Store API explains both problems at once: Switzerland is not a country of that channel, and the code's promotion ended in August. Then the search explains why a product never shows up.

checkout_simulate explains a blocked country and an expired code; storefront_search explains an invisible product

Every morning, one page. shopware-mcp brief --html brief.html writes the pulse, the audit and the last seven days as one self-contained page that loads nothing from anywhere and follows the reader's dark mode. From cron, with --slack for a one-paragraph summary in a channel. Open a real one.

Least privilege in one command. shopware-mcp setup logs in as an admin once, creates a role with exactly the privileges the tools need, measured against a real shop and not guessed, and an integration that is not an administrator. It shows the secret once, verifies both and prints the host config. Run it again after an upgrade and it brings the role up to date while the keys stay.

shopware-mcp setup creates a read-only role with 51 privileges and an integration, shows the secret once, verifies 28 of 28 read tools, leaves out shop_settings and prints the Claude Code command

Every recording on this page is real output from the server against a Shopware 6.7.13 test shop with generated demo data, replayed from the transcripts in docs/demo/. Tool calls and results are verbatim, shortened to fit the screen. The prose is what an MCP host says with them.

One question, one call. Three paid orders are still waiting for shipment, the storefront is in maintenance, a summer promotion outlived August. The answer names order numbers and amounts, and offers the safe next step.

shop_audit: the agent asks one question, the tool returns prioritised findings with samples, the agent summarises them

Numbers the shop computed itself. Totals, channels, states, a monthly timeline and the top product for eight months, from one call. No order was paged through; Shopware's aggregations did the work.

sales_report: totals, revenue by channel, orders by state, a monthly timeline and top products

No tool for that? There is a schema for that. Manufacturers have no dedicated tool. The agent reads the entity's schema, spots mediaId, and filters on it. The same path reaches every other entity, custom ones included.

entity_schema then entity_search: the agent discovers the mediaId field and finds 27 manufacturers without a logo

Writes show their hand first. With --allow-write, a stock correction comes back as the request it would send. Only an explicit dryRun: false touches the shop, and the result is re-read from Shopware.

stock_set: a dry run returns the PATCH it would send, the agent asks, the real write follows and returns the re-read product

Ship it, then prove it. A delivery transition is two requests, shown before they are sent: the tracking code onto the delivery, then the state change. The order's history afterwards names the transition, the states and who made it.

order_delivery_transition then order_history: the dry run lists both requests, the write ships the order, the history shows the transition and the integration that made it

A product and its launch code, from one sentence. product_create picks the shop's default tax and derives the net price, and says so in the dry run. The promotion arrives inactive, so nobody sees a code before it was checked.

product_create and promotion_create: the dry run shows the POST with tax and net price, the product is created, the promotion follows inactive

Moderation with a reply. Two reviews wait for approval. The spam stays hidden, the complaint is approved together with the shop's public answer, and the model never had to touch the admin.

reviews_search then review_moderate: two pending reviews, one approved with a reply after a dry run

People, not just revenue. New accounts by group, how many customers ordered and how many came back, the guest share, and the top customers with their share of the period, next to the period before.

customer_report: new customers, ordering and repeat customers, comparison with the previous period and the top customers by revenue

A shop with more plugins gets a bigger agent. The core tools are ready immediately. The extension lookup finishes in the background, four tools appear, the host is told to refresh its list, and a compliance question has an answer.

Plugin-aware tools: tools/list grows from 23 to 27 after the extension lookup, then merqo_health answers a compliance question

Reorder before it hurts. stock_forecast reads six months of line items through one aggregation, joins them with the current stock, and says per product how many days are left, when it hits zero, and how much to order. Nine of these are already oversold; two are still fine today and will not be in October.

stock_forecast: eleven products that run out within 60 days, with sales per day, days of cover, run-out date and a suggested reorder quantity

The same audit, no host in sight. shopware-mcp audit prints the findings as Markdown and exits non-zero when something is critical (or, with --fail-on warning, when anything is off). Put it in cron and read the mail; put it in CI and let the job fail. shopware-mcp report does the same for the numbers.

shopware-mcp audit and report on the command line: Markdown findings with exit code 1, then a monthly sales report table

A shop with an operations plugin gets an operations agent. FroshTools is the open-source toolbox many Shopware hosters install. When it is there, three more tools appear: the platform's health checks, the message queue with its worker, and the dependency advisories. The agent tells stale search results apart from a dead worker.

FroshTools pack: frosh_health lists the failing platform checks, frosh_queue shows 134 waiting messages and no worker, the agent names the cause

Fifty-six invoices, three at a time. order_documents_bulk_create finds the paid orders that never got an invoice, oldest first, and shows the single request that would create them before it does. Every order counts against the write budget. Then scheduled_tasks_list explains how the backlog grew: 31 of 33 tasks overdue, none ever run, the scheduler is not running. tag_assign marks the order for the team, creating the tag on the way.

order_documents_bulk_create dry run and apply for three orders, scheduled_tasks_list with 31 overdue tasks, tag_assign dry run creating the tag invoice-sent

Know before the agent finds out. shopware-mcp doctor probes what the integration may read, reads its role for the write privileges where it can, and names the missing one per tool. An administrator gets a wall of ticks; a support-desk role gets told exactly what to grant.

shopware-mcp doctor: every tool ready for an administrator integration, then a support-desk integration with customers blocked and the privilege to grant

shop_audit result in the MCP Inspector

sales_report result in the MCP Inspector

The tool list with plugin-aware tools registered


What's in the box

Twenty curated tools

products_search, orders_get, customers_search, stock_get, promotions_list, reviews_search, payment_methods_list, shipping_methods_list, plugins_list, scheduled_tasks_list and friends. Each search takes { term?, filter?, sort?, page?, limit?, fields? } and returns { total, page, limit, items }.

Shop settings

shop_settings reads the trading settings from Shopware's system configuration, shop-wide or per sales channel with inheritance: guest checkout, double opt-in, password rules, cart limits, listing defaults, default tax, legal pages. Only an allowlist of core domains; mail servers, licences and plugin secrets are never read.

Order history

order_history lists every order, payment and delivery transition of one order in sequence: previous state, new state, action, and whether an admin user, an API integration or Shopware itself triggered it.

Checkout simulation

checkout_simulate fills a throwaway cart through Shopware's admin proxy to the Store API, the route the admin's own order dialog uses: as a guest with a shipping country, or logged in as a customer with their group, prices, rules and address. It returns prices per item next to the listing price, discounts, shipping, taxes, the total, the payment and shipping methods offered and the ones hidden with the rule that hides them, and every cart error with a plain explanation. Nothing is ordered, the cart is deleted.

Storefront search

storefront_search runs a search in a sales channel the way a customer does, same visibility, stock and closeout rules, same ranking and prices, and explains one product on request: its position, or why it is missing (inactive, not visible in the channel, link-only, closeout without stock, not in the search index, no keyword matching the term).

Shop pulse

shop_pulse compares orders and revenue since local midnight with the same hours of the same weekday in the last 2 to 12 weeks or around this day last year, optionally times an expected factor, weighs the current quiet spell with a Poisson estimate, and watches today's failed payments against their usual share. One aggregation request, whatever the shop's size.

Campaign check

promotions_check for every promotion that runs or starts before a date, active or not: findings per promotion, worst first, checked the way Shopware decides whether a code or an automatic discount applies.

Returns report

returns_report for any period: the share of orders that came back in full or in part next to the period before, the revenue of returned orders, and products ranked by the share of their orders that came back. Shopware records returns per delivery, so the tool says so instead of pretending to know items.

Health audit

shop_audit with tunable thresholds (stuckOrderDays, lowStockThreshold, forecastDays, maxItems). Eighteen checks including a checkout that went silent, promotions that will not work, paid orders without an invoice, products running out at the current pace, legal pages per storefront, delivery times, sales channel visibility, pending reviews and scheduled tasks that stopped running, prioritised findings, a hint per finding, and an EU duty overview that names duties and deadlines, never products.

Sales report

sales_report for any period, by day, week or month, optionally per sales channel, cancelled orders excluded. compareWithPrevious adds the preceding period and the change in orders, revenue and average order value. Top products resolved by exact product id so ties cannot skew revenue.

Customer report

customer_report for the same periods: new accounts split into registered and guest and by group, distinct ordering customers, repeat share, guest order share, and the top customers by revenue with their share of the total.

Stock forecast

stock_forecast for 'what do I need to reorder?': units sold per product in a window, current available stock, days of cover, the run-out date and a reorder quantity that covers the horizon plus a restock period. Nothing is estimated for products without sales.

Any entity

entity_schema lists all entities or describes one: fields, types, flags, associations. entity_search queries it, with Shopware aggregations (terms, sum, avg, min, max, count, stats, histogram, one nested metric) over the whole match on request. Long text values are truncated, secrets scrubbed, credential entities and credential fields refused.

Plugin-aware tools

The server detects installed, active extensions and adds tools for the ones it knows. Packs: FroshTools (platform health checks, message queue, dependency advisories) and Merqo. Off with --no-extensions.

Documents

order_documents_list, order_document_create (invoice, delivery note, credit note, cancellation, by Shopware's own generator), order_documents_bulk_create (one document type for up to fifty orders in one request, by default the paid orders that have none yet) and document_download, which hands the PDF to the host as an embedded resource while the model sees only the metadata.

Guarded writes

stock_set (absolute or delta), product_update, product_create, product_cover_set (a picture from a URL or bytes, uploaded by the shop), order_state_transition, order_delivery_transition (ship, with tracking codes), order_transaction_transition (mark paid, remind, refund), order_note (internal comment), order_document_create, order_documents_bulk_create, promotion_toggle, promotion_create, customer_update, review_moderate, tag_assign (tags by name on a customer, order or product; missing tags are created). Registered only with --allow-write, dryRun: true by default, the re-fetched entity on a real write. SHOPWARE_MCP_MAX_WRITES caps real writes per process, and a bulk call counts once per order.

A command line too

shopware-mcp setup creates a least-privilege integration from one admin login. shopware-mcp doctor says per tool whether this integration can use it and which privilege is missing. shopware-mcp init tests the credentials and prints or writes the config for Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, Gemini CLI, Codex CLI or Zed. shopware-mcp brief, audit and report print Markdown or JSON, write a self-contained HTML page with --html and the JSON with --json-file, and exit non-zero for cron and CI; brief and audit also post a summary to Slack with --slack, run the shop's own rules with --rules, and brief --history keeps a health score per day and draws the trend. shopware-mcp watch keeps an eye on orders, payments and customer journeys and alerts on change with the likely cause, in a loop or once per cron run.

A GitHub Action

uses: bnymnDev/shopware-mcp@v0.10.0 runs the audit in a workflow with the shopware-mcp release of that tag, writes the Markdown into the job summary, exposes the counts and the exit code as outputs and fails the job on the severity you choose.

Resources and prompts

shopware://shop, shopware://sales-channels, the templates shopware://order/{orderNumber}, shopware://product/{productNumber} and shopware://customer/{customerNumber} so a host can attach a record as context, and seven prompts: order_summary, customer_profile, low_stock_report, reorder_list, review_moderation, weekly_review and campaign_ready.

Shopware's vocabulary

Filters are Shopware Criteria filters (equals, contains, range, equalsAny) on Shopware field paths, including associations like manufacturer.name. State names are the technical names you already know.

Portable schemas

Every tool schema is checked to avoid constructs that some MCP clients misread, so the same server works in every host.

A solid client

OAuth client credentials with early token refresh, one retry on 401 and on 429/5xx with Retry-After, a per-request timeout, exact totals, inheritance and language headers, a cached entity schema.

Three ways to serve

stdio for desktop hosts, stateless Streamable HTTP with an optional bearer token, and a hosted mode for many shops behind OAuth 2.1 (PKCE, dynamic client registration, client ID metadata documents).

Packaged four ways

npm with build provenance, a Docker image on GHCR for amd64 and arm64, a one-click .mcpb bundle for Claude Desktop that asks for the credentials and a write budget, and a listing in the official MCP registry.


Who it is for

  • You run a shop and want to ask it questions instead of clicking through the admin. Stuck orders, low stock, last month's numbers, one prompt each.

  • You run an agency and look after many shops. The core here covers one shop per server; the multi-shop, audited, hosted version is what the author builds for clients (see Open core).

  • You build Shopware plugins and want your custom entities reachable by an agent today, and your own tools registered tomorrow. entity_search does the first; one file under src/extensions/ does the second.

  • You build agents and want an MCP server that behaves: compact output, honest totals, dry runs, no surprises in the schema.


60 seconds

1. Let setup create the integration. It logs in as an admin once (the password is never stored), creates a read-only role with exactly the privileges the tools need and an integration using it, verifies both and prints or writes the host config:

npx shopware-mcp setup --url https://shop.example.com --user admin --for claude-desktop --write

Add --allow-write for the write tools and --settings for shop_settings; --dry-run shows the role's privileges first. After an upgrade, run the same command again: it updates the role and keeps the keys. Rather click it yourself? Create an Integration under Settings → System → Integrations, give it a role (see permissions) and continue with step 2.

2. Or let the wizard test existing credentials and write the host config for you:

npx shopware-mcp init                  # asks for URL, key and secret, tests them, prints the config
npx shopware-mcp init --for claude-desktop --write   # or merges it into the host's config file
npx shopware-mcp doctor                # which tools can this integration use, and what is missing
npx shopware-mcp audit --fail-on warning   # the shop audit as Markdown, exit 1 when something is off
npx shopware-mcp report --interval week    # the sales report of the last 30 days as Markdown
npx shopware-mcp brief --html brief.html   # pulse, audit and the last 7 days as one HTML page

Or run the server by hand:

export SHOPWARE_URL=https://shop.example.com
export SHOPWARE_CLIENT_ID=SWIA...
export SHOPWARE_CLIENT_SECRET=...

npx shopware-mcp                       # stdio (default)
npx shopware-mcp --http --port 3333    # Streamable HTTP on http://127.0.0.1:3333/mcp
npx shopware-mcp --allow-write         # also register the guarded write tools

3. Connect a host (or let init --write do it):

Download shopware-mcp.mcpb from the latest release and double-click it, or add this to claude_desktop_config.json:

{
  "mcpServers": {
    "shopware": {
      "command": "npx",
      "args": ["-y", "shopware-mcp"],
      "env": {
        "SHOPWARE_URL": "https://shop.example.com",
        "SHOPWARE_CLIENT_ID": "SWIA...",
        "SHOPWARE_CLIENT_SECRET": "..."
      }
    }
  }
}
claude mcp add shopware \
  -e SHOPWARE_URL=https://shop.example.com \
  -e SHOPWARE_CLIENT_ID=SWIA... \
  -e SHOPWARE_CLIENT_SECRET=... \
  -- npx -y shopware-mcp

They all take the same three fields. Cursor reads .cursor/mcp.json, VS Code .vscode/mcp.json (under servers instead of mcpServers), Windsurf ~/.codeium/windsurf/mcp_config.json, Gemini CLI ~/.gemini/settings.json, Codex CLI a [mcp_servers.shopware] table in ~/.codex/config.toml, Zed its context_servers block. init --for <host> --write writes each of them:

{
  "mcpServers": {
    "shopware": {
      "command": "npx",
      "args": ["-y", "shopware-mcp"],
      "env": {
        "SHOPWARE_URL": "https://shop.example.com",
        "SHOPWARE_CLIENT_ID": "SWIA...",
        "SHOPWARE_CLIENT_SECRET": "..."
      }
    }
  }
}

Hosts that read the official MCP registry find it as io.github.bnymnDev/shopware-mcp.

docker run --rm -p 3333:3333 \
  -e SHOPWARE_URL=https://shop.example.com \
  -e SHOPWARE_CLIENT_ID=SWIA... -e SHOPWARE_CLIENT_SECRET=... \
  ghcr.io/bnymndev/shopware-mcp

The image serves Streamable HTTP on http://127.0.0.1:3333/mcp. Point any HTTP-capable host at that URL. Add -e SHOPWARE_MCP_HTTP_TOKEN=<random secret> and the endpoint requires Authorization: Bearer <secret>; without a token, keep it on localhost or behind a proxy that authenticates (self-hosting notes).

4. Ask. The first useful question is usually "Is everything okay with the shop?"


Ask it anything

You say

The agent calls

"Is today normal?"

shop_pulse

"Why can't customer 10009 check out?"

checkout_simulate { customerNumber: "10009", items }

"Why does the code SUMMER26 not work?"

checkout_simulate { promotionCodes: ["SUMMER26"], items }

"What does shipping to Switzerland cost?"

checkout_simulate { country: "CH", items }

"Why can nobody find the steel shirt?"

storefront_search { term: "steel shirt", explain: "SW10002" }

"Is everything okay with the shop?"

shop_audit

"How did we do in August?"

sales_report { from, to, interval: "week" }

"Which products are below 5 in stock?"

products_search with a range filter, or the low_stock_report prompt

"Summarise order 10042 for a support reply."

orders_get, or the order_summary prompt

"Which customers ordered more than ten times?"

customers_search with a range filter on orderCount

"Is the PayPal plugin up to date?"

plugins_list

"Which manufacturers have no logo?"

entity_schema then entity_search on product_manufacturer

"Set the stock of SW10084 to 40."

stock_set, dry run first, then for real

"Order 10042 shipped with DHL, tracking 00340434."

order_delivery_transition { transition: "ship", trackingCodes }

"The bank transfer for 10038 arrived."

order_transaction_transition { transition: "paid" }

"How was last week compared to the week before?"

sales_report { compareWithPrevious: true }, or the weekly_review prompt

"Send me the invoice for 10042."

order_documents_list, then document_download returns the PDF

"Note on 10042: customer called, ships Monday."

order_note

"What happened to order 10042, and who did it?"

order_history

"Who is customer 10042 and what did they order last?"

customers_get and orders_search, or the customer_profile prompt

"Who were our best customers this quarter?"

customer_report { from, to, topCustomers: 20 }

"Which reviews are waiting for approval?"

reviews_search with status: false, or the review_moderation prompt

"Approve the review from Dominique and thank her."

review_moderate { approved: true, comment }

"Which payment methods does the storefront offer?"

payment_methods_list, shipping_methods_list

"Create a 10 % code AUTUMN10 for October."

promotion_create, created inactive until you say otherwise

"Add the product Bench, SW10200, 119 euro, 3 in stock."

product_create, net price derived from the tax rate

"Two came back from the customer, add them to SW10084."

stock_set { delta: 2 }

"What do I need to reorder in the next two weeks?"

stock_forecast, or the reorder_list prompt

"Orders per payment method last month, with revenue?"

entity_search on order with a terms aggregation and a nested sum

"Which paid orders have no invoice yet? Create them."

shop_audit, then order_documents_bulk_create { type: "invoice" }, dry run first

"Are the cron jobs running at all?"

scheduled_tasks_list { onlyProblems: true }

"Mark this customer as VIP."

tag_assign { entity: "customer", add: ["VIP"] }

"Is guest checkout on, and what is the default tax?"

shop_settings

"Give SW10084 this picture: https://…/bench.jpg"

product_cover_set, the shop downloads it

"Thumbnails are missing, is the platform okay?"

frosh_health and frosh_queue, when FroshTools is installed

"Set it up with the least rights it needs."

not a tool: npx shopware-mcp setup

"Which of my tools will fail with this integration?"

not a tool: npx shopware-mcp doctor

"Send me one page every morning."

shopware-mcp brief --html brief.html --slack <webhook> in cron

"Will our Black Friday codes work?"

promotions_check, or the campaign_ready prompt

"Tell me if orders stop on Black Friday."

shopware-mcp watch --baseline last-year --expect 3 --slack <webhook>

"What do customers send back most?"

returns_report

"Orders stopped. Why?"

shop_diagnose

"Can a Swiss guest still pay with PayPal?"

journeys_run, or watch --journeys journeys.json

"What would 20 % off over 50 euro have cost us last month?"

promotion_impact { discount: { type: "percentage", value: 20 }, minCartValue: 50 }

"Do we sell anything below cost?"

margin_check

"Is the shop getting better or worse?"

shopware-mcp brief --history health.json keeps a score per day

"How is the shop doing?"

shop_brief, a page in hosts that show MCP Apps

"Can ChatGPT and Gemini sell our products?"

agent_readiness, then shopware-mcp feed --out feed.jsonl

"Can we update to 6.8 yet?"

update_check

"Are we ready for the GPSR?"

shop_audit { rulePacks: ["gpsr", "eaa"] }

"Mail me the audit every Monday."

not a tool either: shopware-mcp audit --fail-on warning in cron


Filters, in one screen

Every search tool takes the same filter array, and every entry is a Shopware Criteria filter:

{ "type": "equals",    "field": "active",                                    "value": true }
{ "type": "range",     "field": "stock",                                     "value": { "lt": 5 } }
{ "type": "range",     "field": "orderDateTime",                             "value": { "gte": "2026-06-01" } }
{ "type": "equals",    "field": "transactions.stateMachineState.technicalName", "value": "paid" }
{ "type": "contains",  "field": "name",                                      "value": "shirt" }
{ "type": "equalsAny", "field": "id",                                        "value": ["…", "…"] }
{ "type": "equals",    "field": "manufacturer.name",                         "value": "Acme" }

Anything you can filter in the Admin API works here too, associations included. Need a raw field that the compact output leaves out, such as customFields, ean or weight? Pass fields: ["customFields", "ean"] and it is added to every item. Reading a shop in another language? Set SHOPWARE_LANGUAGE_ID. The full cheat sheet has more.


Tools

Tool

Access

Purpose

shop_info

read

Shop info

shop_settings

read

Shop settings

sales_channels_list

read

List sales channels

products_search

read

Search products

products_get

read

Get product

orders_search

read

Search orders

orders_get

read

Get order

order_history

read

Order history

order_documents_list

read

List order documents

document_download

read

Download document PDF

customers_search

read

Search customers

customers_get

read

Get customer

categories_list

read

List categories

promotions_list

read

List promotions

promotions_check

read

Check promotions before a campaign

promotion_impact

read

What would a discount cost?

margin_check

read

Margins: below cost and thin

reviews_search

read

Search product reviews

payment_methods_list

read

List payment methods

shipping_methods_list

read

List shipping methods

plugins_list

read

List plugins and apps

scheduled_tasks_list

read

Scheduled tasks

stock_get

read

Get stock

stock_forecast

read

Stock forecast

storefront_search

read

Search like a customer

checkout_simulate

read

Simulate a checkout

journeys_run

read

Run customer journeys

agent_readiness

read

Ready for AI shopping agents?

update_check

read

Ready for the next Shopware update?

shop_diagnose

read

Why are orders not coming in?

sales_report

read

Sales report

customer_report

read

Customer report

returns_report

read

Returns report

shop_pulse

read

Shop pulse

shop_brief

read

Shop brief

shop_audit

read

Shop health audit

entity_schema

read

Entity schema

entity_search

read

Search any entity

stock_set

write (guarded)

Set stock (guarded)

product_update

write (guarded)

Update product (guarded)

product_create

write (guarded)

Create product (guarded)

product_cover_set

write (guarded)

Set product cover image (guarded)

order_state_transition

write (guarded)

Transition order state (guarded)

order_delivery_transition

write (guarded)

Transition delivery state (guarded)

order_transaction_transition

write (guarded)

Transition payment state (guarded)

order_note

write (guarded)

Add internal order note (guarded)

order_document_create

write (guarded)

Create order document (guarded)

order_documents_bulk_create

write (guarded)

Create documents for many orders (guarded)

promotion_toggle

write (guarded)

Toggle promotion (guarded)

promotion_create

write (guarded)

Create promotion (guarded)

customer_update

write (guarded)

Update customer (guarded)

review_moderate

write (guarded)

Moderate review (guarded)

tag_assign

write (guarded)

Assign tags (guarded)

Every parameter of every tool: docs/tools.md. Searches return { total, page, limit, items } with exact totals, limit is capped at 50, and errors come back as { error: { status, code, detail } } so the model can react instead of guessing.

Resources: shopware://shop, shopware://sales-channels, shopware://order/{orderNumber}, shopware://product/{productNumber}. Prompts: order_summary, low_stock_report, weekly_review.

Plugin-aware tools

At startup the server asks the shop which extensions are installed and active, in the background, and registers extra tools for the ones it knows. A shop that does not answer simply keeps the core tools. --no-extensions turns the whole mechanism off.

Two packs ship today. FroshTools, the open-source operations plugin, adds frosh_health (platform health and performance checks), frosh_queue (message queue transports, waiting messages, worker) and frosh_composer_audit (dependency advisories); all read-only, the plugin's own maintenance actions are never called. Merqo adds merqo_health, merqo_einvoice_inbox, merqo_returns_search and merqo_abandoned_carts. Shops without a plugin never see its tools, and nothing in the core tools changes either way. Support for another vendor's extensions is one file under src/extensions/, tested against the installed plugin; a pack names the ACL privileges its plugin's routes need, and shopware-mcp setup grants them when that plugin is installed. Pull requests are welcome.


Safety

  • Read-only by default. Without --allow-write (or SHOPWARE_MCP_ALLOW_WRITE=true) the write tools are not registered. An agent cannot discover what it cannot call.

  • Every write is a dry run first. All fifteen write tools, from stock_set to tag_assign, default to dryRun: true and return { dryRun: true, wouldSend: { method, url, body } }, a list when one call needs several requests. A real write returns the re-fetched entity.

  • A write budget. SHOPWARE_MCP_MAX_WRITES=20 refuses the twenty-first real write of a process with WRITE_BUDGET_EXHAUSTED; dry runs stay free. No prompt can lift it.

  • Narrow writes. product_update touches name, description, active and one currency's price; product_create makes a simple product and nothing else; product_cover_set adds one picture (JPEG, PNG, WebP, GIF or AVIF, never SVG) that the shop itself downloads. promotion_create creates one cart discount, inactive unless told otherwise. customer_update touches the active flag and the group. The transition tools only move state machines; nothing moves money. Documents come from Shopware's own generator and are never sent by this server; order_documents_bulk_create makes at most fifty per call and charges the write budget once per order. tag_assign adds or removes tags by name and leaves the rest of the record alone. Nothing deletes. Nothing else is writable.

  • A simulated cart is not an order. checkout_simulate and storefront_search go through Shopware's own admin proxy to the Store API with a random context token no visitor holds. The order route is never called and the cart is deleted afterwards; what remains is a context row Shopware expires by itself. Simulating as a customer does not touch that customer's own session or saved cart. Extensions that react to saved carts, such as abandoned-cart mailers, do see the simulated cart as that customer's, so simulate as a real customer only where that is fine.

  • Least privilege by default. shopware-mcp setup grants each tool exactly the privileges it was measured to need against a role that had nothing else, and never administrator rights. Two privileges reach further than their tool and stay out unless you ask: reading the whole system config, SMTP passwords and payment keys included (--settings), and installing extensions (--plugin-updates). Setup only changes a role it created, names every privilege it adds or removes, and shows the new secret before anything else can fail. The admin password is used for one login over https, or plain http to this machine only, and never stored.

  • Scrubbed reads. entity_search strips passwords, keys, tokens and hashes from every payload and refuses entities that exist to hold credentials or system internals: users, integrations, ACL roles, apps, system config.

  • No secrets anywhere. Credentials never appear in output, logs or error messages. Logs go to stderr only, at error level unless you ask for more.

  • No telemetry. The server talks to your shop and to your host. Nothing else.

  • HTTP transport. Set SHOPWARE_MCP_HTTP_TOKEN and every call to /mcp needs that bearer token, compared in constant time. Without it, bind to localhost (the default) or put it behind a reverse proxy that authenticates; the server warns when it is reachable further without a token.

  • Requests time out. A shop that stops answering costs one request 30 seconds (SHOPWARE_MCP_TIMEOUT_MS), not the whole session.

Found something? See SECURITY.md.


Configuration

Variable

Required

Notes

SHOPWARE_URL

yes

Shop base URL, e.g. https://shop.example.com (trailing slash is stripped)

SHOPWARE_CLIENT_ID

yes

Integration access key ID

SHOPWARE_CLIENT_SECRET

yes

Integration secret access key

SHOPWARE_MCP_ALLOW_WRITE

no

true registers the write tools. Default: off

SHOPWARE_MCP_MAX_WRITES

no

Real writes one process may perform in total; 0 (default) means no cap

SHOPWARE_MCP_DEFAULT_LIMIT

no

Default page size for search tools (default 20, max 50)

SHOPWARE_MCP_EXTENSIONS

no

false disables plugin-aware tools and the extension lookup at startup

SHOPWARE_LANGUAGE_ID

no

Language UUID for translated fields (sw-language-id). Default: shop default language

SHOPWARE_MCP_TIMEOUT_MS

no

Per-request timeout for the Admin API in milliseconds (default 30000, 1000 to 600000)

SHOPWARE_MCP_HTTP_TOKEN

no

Bearer token the HTTP transport requires on /mcp (at least 16 characters). Default: none

SHOPWARE_MCP_LOG_LEVEL

no

error (default), warn, info, debug. Logs go to stderr only

TZ

no

Time zone for "today" in shop_pulse and brief, e.g. Europe/Berlin. Default: the system's. It also picks the public holidays the pulse leaves out (DE, AT, CH)

SHOPWARE_MCP_RULES

no

Rule packs and files for the audit, e.g. gpsr,eaa,feeds,./rules.json (example)

SHOPWARE_MCP_JOURNEYS

no

JSON file with customer journeys for journeys_run (example)

SHOPWARE_ADMIN_USER, SHOPWARE_ADMIN_PASSWORD

setup only

The admin login setup uses once to create the role and integration. Never stored; without them setup asks

CLI flags override the environment: --allow-write, --max-writes <n>, --no-extensions, --http, --port <n>, --host <addr>, --log-level <level>. Commands: setup, doctor, init, brief, audit and report; npx shopware-mcp --help lists their options.

The Integration needs read permissions on the entities the tools touch and write permissions for the write tools. shopware-mcp setup grants exactly those; Administrator is the quick path for a dev shop (which permissions).


Design principles

  1. Shopware's vocabulary, not ours. Filters, field paths, state names and entity names are Shopware's. A tool call reads like the Admin API request it becomes, and a Shopware developer needs no second dictionary.

  2. Compact by default, complete on request. Items carry what a model needs to reason and page. Raw fields come with fields, more rows with page, and long text is truncated rather than dumped.

  3. Reading is free, writing is explicit. Write tools exist only when asked for, default to a dry run, and return the exact request. The model sees the consequence before the shop does.

  4. Let the shop do the maths. Totals, timelines and top products are Shopware aggregations with exact counts, not client-side sums over pages.

  5. Vendor-neutral core. Extension packs live in their own files, are registered only when the shop has the extension, and never change how the core tools behave. No telemetry, no phone-home.

The reasoning behind individual choices is in docs/decisions.md.


Documentation

Document

What is in it

docs/quickstart.md

Integration, first run, host configs, example questions, the filters cheat sheet

docs/tools.md

Every tool with every parameter, generated from the code

docs/self-hosting.md

Transports, Docker, reverse proxies, Shopware permissions, operations

docs/decisions.md

Design decisions and the reasoning behind each

CONTRIBUTING.md

Setup, ground rules, end-to-end tests, releasing

SECURITY.md

What to report and where

CHANGELOG.md

What changed in each version


Open core

Everything in this repository is MIT and stays that way. It covers one shop, one operator, interactive use.

The same author builds Merqo, a commercial suite of Shopware extensions for EU compliance and daily operations. This server detects them and adds matching tools, but it never requires them, and the core tools behave the same either way.

Agencies and merchants running this at scale usually need more, and that is what I build and operate for clients:

  • Multi-shop: one MCP endpoint that routes to dozens of shops with per-shop credentials and permissions

  • Hosted with audit trail: every tool call logged with who, what and when, role-based access, SLA

  • Bulk operations and migrations: mass price and stock updates, catalogue imports, safe rollbacks

  • Custom agents and Shopware plugins: workflows tailored to your ERP, PIM or support desk

Interested? Open an issue with the consulting label or reach out via github.com/bnymnDev. Using shopware-mcp in production and want it to stay maintained? Sponsoring helps.


Building from source

pnpm install
pnpm dev          # stdio server via tsx
pnpm test         # vitest + msw-mocked Admin API
pnpm build        # tsup → dist/ (npm) and dist/bundle/ (self-contained)
pnpm pack:mcpb    # Claude Desktop bundle → shopware-mcp.mcpb
pnpm inspect      # MCP Inspector against dist/
pnpm docs:tools   # regenerate docs/tools.md and the tool tables in both READMEs
pnpm docs:demos   # re-render the recordings in docs/demo/ from their transcripts

End-to-end tests against a real Shopware (dockware/dev, or any shop you point them at) run with pnpm test:e2e; see CONTRIBUTING.md.


Status

v0.9. Everything on this page is implemented, covered by unit tests against mocked Admin API responses, and exercised nightly end-to-end against a real Shopware. The recordings above come from Shopware 6.7.13; 6.6 is supported too.

Not in it, on purpose: user management for the HTTP transport (one static token, or a proxy), multi-shop routing and audit trails (the commercial part), and write tools beyond the fifteen that a support desk and a shop manager need on a normal day.

Ideas that fit: more extension packs, more cart errors explained in plain words, a products_search example gallery. The good first issues are a fine place to start.

License

MIT

Available Tools

38 tools
agent_readinessReady for AI shopping agents?A
Read-onlyIdempotent

Can AI shopping agents (ChatGPT, Gemini, Perplexity, Copilot) find and sell this shop's products? Builds the product feed agents read (Agentic Commerce feed fields, as Google Merchant) from the storefront's visible products and checks each row: name, description, brand, image and price are required; GTIN with a valid check digit, manufacturer number and weight help agents match and ship. Also checks HTTPS and the privacy, terms and revocation pages an agent checkout links to. Read-only. Returns { score (0 to 100), products, gaps[] with share and samples, shop[], checkoutReady, feedSample[] }.

Inputs: maxItems, salesChannelId.

categories_listList categoriesA
Read-onlyIdempotent

List categories as a flat list with parentId and level so you can rebuild the tree. Each item includes productCount (directly assigned products). Filter by parentId to get one level, or by level=1 for the roots. Returns { total, page, limit, items[] }.

Inputs: page, sort, term, limit, +2 more.

checkout_simulateSimulate a checkoutA
Read-only

See the checkout the way a customer does: puts products (and promotion codes) into a throwaway cart of a sales channel through Shopware's own Store API, as a guest shipping to a country or as a given customer with their group, prices and rules, and returns what Shopware calculates: prices per item next to the listing price, discounts, shipping, taxes, total, which payment and shipping methods the customer is offered, which are hidden and by which rule, and every cart error with a plain explanation (country not assigned, code expired, product not visible, stock). Nothing is ordered and the cart is deleted afterwards; as a customer, extensions that react to saved carts (abandoned-cart mailers) see it like any other cart of that customer. Use it for 'why can't this customer order?', 'why does this code not work?' or 'what does shipping to Switzerland cost?'. Returns { salesChannel, as, canOrder, items[], promotions[], shipping, totals, problems[], paymentMethods, shippingMethods }.

Inputs: items (required), country, salesChannel, paymentMethod, +3 more.

customer_reportCustomer reportA
Read-onlyIdempotent

Customer figures for a period straight from Shopware: new accounts (registered vs guest, by customer group), how many distinct customers ordered, the repeat share (two or more orders in the period), the guest order share and the top customers by gross revenue with their share of the total. compareWithPrevious adds the period of equal length before from and the change. Defaults to the last 30 days, cancelled orders excluded. Returns one object.

Inputs: to, from, topCustomers, salesChannelId, +2 more.

customers_getGet customerA
Read-onlyIdempotent

Get one customer by ID, customer number or email, including all addresses (with default billing/shipping flags), customer group, default and last used payment method. Returns one object.

Inputs: email, fields, customerId, customerNumber.

document_downloadDownload document PDFA
Read-onlyIdempotent

Fetch one order document (invoice, delivery note, credit note, cancellation invoice) as a PDF. The file is returned to the host as an embedded resource next to the document's metadata; the model sees the metadata only. Get the documentId from order_documents_list. Read-only, nothing is marked as sent. Returns { id, type, documentNumber, orderNumber, mimeType, bytes, attachments[] }.

Inputs: documentId (required).

entity_schemaEntity schemaA
Read-onlyIdempotent

Describe a Shopware entity: its fields (name, type, flags such as required/translatable) and associations (name, relation, target entity), taken from the shop's own entity schema. Call it without entity to list all entity names. Use it to build precise filters for entity_search or the fields parameter of other tools. Returns one object.

Inputs: entity.

journeys_runRun customer journeysA
Read-only

Synthetic customers: run fixed buying paths through the shop's real cart, e.g. 'Swiss guest with code SUMMER26', 'regular customer pays by invoice', and say which one broke and why. Each journey takes the inputs of checkout_simulate plus expectations: the cart can be ordered, given payment or shipping methods are offered, codes apply, the total stays in a range. Without journeys it runs the ones in SHOPWARE_MCP_JOURNEYS (a JSON file). Nothing is ordered; carts are deleted. Returns { ok, passed, failed, results[] }.

Inputs: journeys.

margin_checkMargins: below cost and thinA
Read-onlyIdempotent

Find active products whose net price is below their purchase price, products with a thin margin, and products that an automatic discount running right now pushes below cost: the '60 % instead of 6 %' mistake on the price side. Uses Shopware's purchase price; products without one are counted, not guessed. Read-only. Returns { checked, withoutPurchasePrice, automaticDiscount, summary, belowCost[], thin[], lossWithDiscount[] }.

Inputs: maxItems, minMargin.

order_documents_listList order documentsA
Read-onlyIdempotent

List the documents generated for one order: invoices, delivery notes, credit notes and cancellation invoices, with document number, type, creation date and whether they were sent. Use document_download to fetch one as PDF. Returns { orderId, orderNumber, total, items[] }.

Inputs: orderId, orderNumber.

order_historyOrder historyA
Read-onlyIdempotent

The state history of one order: every order, payment and delivery transition in chronological order with the previous and new state, the action name and who triggered it (admin user, API integration or the system). Use it for 'what happened to this order and when?'. Orders imported without transitions have an empty history. When there are more transitions than limit, the newest ones are kept. Returns { orderId, orderNumber, orderDate, total, entries[], note? }.

Inputs: limit, orderId, orderNumber.

orders_getGet orderA
Read-onlyIdempotent

Get one order by ID or order number with line items, billing/shipping addresses, transactions (payment method and state) and deliveries (shipping method, tracking codes). Use it to answer detailed questions about a single order. Returns one object.

Inputs: fields, orderId, orderNumber.

payment_methods_listList payment methodsA
Read-onlyIdempotent

List payment methods with active flag, handler (plugin), availability rule and the sales channels they are assigned to. Filter e.g. active=true or salesChannels.id. Use it for 'which payment methods do we offer?' and to explain why one is missing at checkout. Returns { total, page, limit, items[] }.

Inputs: page, sort, term, limit, +2 more.

plugins_listList plugins and appsA
Read-onlyIdempotent

List installed plugins and apps with version, active/installed state and the available upgrade version (when the shop can reach the Shopware store). Use it to check whether an extension is installed or outdated. Returns { total, items[] }.

Inputs: type, activeOnly.

products_getGet productA
Read-onlyIdempotent

Get one product by ID with everything an agent usually needs: description, price, stock, tax, manufacturer, categories, properties, media and all variants with their options, stock and price. Use products_search or stock_get to find the ID first. Returns one object.

Inputs: productId (required), fields.

promotion_impactWhat would a discount cost?A
Read-onlyIdempotent

Before switching a promotion on: replay its cart discount (or one you describe) on the orders of the last days and say what it would have cost: if every eligible order had used it, and at the share of orders that used a promotion so far. Respects a percentage cap and a minimum cart value; rules that limit who gets it are not evaluated, so the result is an upper bound. Read-only. Returns { orders, revenue, eligibleOrders, scenarios, averagePerOrder, capReached, note }.

Inputs: days, discount, promotionId, minCartValue, +1 more.

promotions_checkCheck promotions before a campaignA
Read-onlyIdempotent

Before Black Friday or any sale: check every promotion that runs or starts before a date, active or not, the way Shopware decides whether it applies. Flags a promotion that starts but is still inactive, has no discount, no sales channel or only channels in maintenance, needs a code but has none, has no unused individual codes left, is close to its redemption limit, gives 50 % or more, ends before it starts, or applies automatically together with another one so the discounts add up. Read-only. Returns { window, checked, summary, promotions[] } with findings per promotion, worst first.

Inputs: until.

promotions_listList promotionsA
Read-onlyIdempotent

List promotions (discount campaigns) with code settings, validity window, redemption limits and a summary of their discounts (scope, type, value). Filter by active or code. Returns { total, page, limit, items[] }.

Inputs: page, sort, term, limit, +2 more.

returns_reportReturns reportA
Read-onlyIdempotent

How many orders came back and which products come back most, from Shopware's own delivery states (returned, returned partially), no plugin needed. Gives the return rate of the period next to the period before, the revenue of returned orders, and products ranked by the share of their orders that came back. Use it for 'what do customers send back?' or before reordering stock. Read-only. Returns { period, totals, previous, change, products[], note }.

Inputs: to, from, minOrders, topProducts, +1 more.

sales_channels_listList sales channelsA
Read-onlyIdempotent

List sales channels (storefronts, headless APIs, marketplaces) with their type, domains and active flag. Use it to find the sales channel or domain an order or product belongs to. Returns { total, page, limit, items[] }.

Inputs: page, sort, term, limit, +2 more.

sales_reportSales reportA
Read-onlyIdempotent

Aggregate sales figures for a period straight from Shopware: order count, gross/net revenue, average order value, breakdowns by order/payment/delivery state, payment method, currency and sales channel, a revenue timeline (day/week/month) and the top-selling products. Use it for 'how did we do last month?' questions instead of paging through orders. compareWithPrevious adds the period of equal length before from and the change in orders and revenue. Defaults to the last 30 days, cancelled orders excluded. Returns one object.

Inputs: to, from, interval, timeZone, +4 more.

scheduled_tasks_listScheduled tasksA
Read-onlyIdempotent

Shopware's scheduled tasks (indexing, cleanups, cache invalidation, plugin jobs) with status, interval, last and next run, and per task whether it is overdue past a grace period, failed, or stuck running for over a day. Many overdue tasks with no recent last run mean the scheduler or message worker is not running, which shows up as stale search results, missing thumbnails and unsent mails. Read-only. Returns { total, summary: { byStatus, overdue, failed, stuck, longestOverdueMinutes, lastRun }, tasks[], problems[], truncated }.

Inputs: graceMinutes, onlyProblems.

shipping_methods_listList shipping methodsA
Read-onlyIdempotent

List shipping methods with active flag, delivery time, tracking URL pattern, availability rule and the sales channels they are assigned to. Filter e.g. active=true or salesChannels.id. Returns { total, page, limit, items[] }.

Inputs: page, sort, term, limit, +2 more.

shop_auditShop health auditA
Read-onlyIdempotent

Run a one-shot health check across the shop and return prioritised findings: paid orders not shipped, old unpaid orders, shipped orders never completed, out-of-stock and low-stock products, products without cover image, delivery time or sales channel visibility, expired promotions still active, promotions in the next 14 days that will not work, sales channels in maintenance mode, storefronts missing legal pages (imprint, terms, privacy, revocation, shipping), reviews awaiting moderation, scheduled tasks overdue or failed, and extensions with pending updates. Each finding has a severity, total count, sample items and a hint. Also reports which EU duties (e-invoicing, accessibility, packaging reporting, AI labelling) appear to be covered by an installed extension, guessed from extension names, and whether Shopware itself is set up for ZUGFeRD e-invoices. The shop's own rules (Shopware filters, e.g. 'active products without a manufacturer') run too: pass them as rules, or point SHOPWARE_MCP_RULES at a JSON file. Ready-made packs check product data for the GPSR, the accessibility act and shopping feeds (rulePacks). Start here when asked 'is everything okay with the shop?'. Read-only. Returns one object.

Inputs: rules, maxItems, timeZone, rulePacks, +4 more.

shop_briefShop briefA
Read-onlyIdempotent

One look at the whole shop, as a manager wants it in the morning: orders and payments right now against a usual day, the audit's findings, and the last seven days' revenue. Hosts that show MCP Apps get it as an interactive page with charts. Read-only. Returns { headline, today, audit, last7Days } in short; use shop_pulse, shop_audit or sales_report for the details of one part.

Inputs: timeZone.

shop_diagnoseWhy are orders not coming in?A
Read-only

Look at the usual suspects in one call when orders stop or customers complain: storefronts in maintenance or inactive, a test purchase of the best seller of the last two weeks with the payment methods really offered, extensions installed or updated in the last 24 hours, errors in Shopware's log in the last 6 hours (failed mails included), and scheduled tasks that stopped. Nothing is ordered. Returns { causes[], fine[] }: likely causes first, and what was checked and found fine.

Inputs: no named parameters.

shop_infoShop infoA
Read-onlyIdempotent

Get basic facts about the connected Shopware shop: version, edition (Community/Commercial), default currency and default language, plus whether write tools are enabled on this server. Use it first to orient yourself or to confirm the connection works. Returns one object.

Inputs: no named parameters.

shop_pulseShop pulseA
Read-onlyIdempotent

How is the shop doing right now? Orders and revenue since local midnight next to the same hours of the same weekday in previous weeks, the last order, and how unusual the current quiet spell is: the orders the same stretch brought in earlier weeks and the chance of seeing none by accident (a Poisson estimate). 'unusual' means the checkout, payment or storefront may be broken; follow up with checkout_simulate. Also compares today's failed or cancelled payments with their usual share. On a campaign day compare with last year (baseline 'last-year') or raise the expectation (expectFactor 3 on Black Friday), so a quiet spell is judged against what the day should bring. Public holidays in the compared weeks are left out (DE, AT, CH). Read-only. Returns { today, typical, change, lastOrder, silence, payments, history[] }.

Inputs: weeks, baseline, holidays, timeZone, +2 more.

shop_settingsShop settingsA
Read-onlyIdempotent

Read the shop's trading settings from Shopware's system configuration, for the whole shop or one sales channel with inheritance: basic information (shop name, contact, legal pages), login and registration (guest checkout, double opt-in, password rules), cart, listing (products per page, sorting, reviews), tax, newsletter, addresses and documents. Only these domains are readable; mail servers, licences and plugin secrets are not, and credential-like keys are dropped. Use it for 'is guest checkout on?' or 'what is the default tax?'. Returns { salesChannelId, inherited, settings: { : { key: value } } }.

Inputs: domains, salesChannelId.

stock_forecastStock forecastA
Read-onlyIdempotent

Which products run out soon, from real sales: units sold per product in the last days (cancelled orders excluded), the current available stock, the days of cover at that pace, the date the stock reaches zero and a reorder quantity that keeps it in stock through the horizon plus restockDays more days (a negative stock is a backlog and is covered too). Lists the active products whose cover is below horizon days, soonest first. Products without sales in the window are never listed. Use it for 'what do I need to reorder?'. Returns { window, horizon, restockDays, total, items[], notes? }.

Inputs: days, limit, horizon, restockDays, +1 more.

stock_getGet stockA
Read-onlyIdempotent

Get stock and available stock for one product by ID or product number, including every variant. Use it for 'how many X are left?' questions. Returns one object with a variants[] list (empty for simple products).

Inputs: productId, productNumber.

update_checkReady for the next Shopware update?A
Read-onlyIdempotent

Before a Shopware update, a major one like 6.8 included: the version available next and the security issues it fixes, Shopware's own requirement checks, and for every extension whether it works with that version (compatible, update the extension first, a compatible version announced, not compatible, or not in the store so test it yourself), straight from Shopware's update service. Read-only: it never starts an update. Needs the privilege system:core:update (and system_config:read for the extensions), which setup grants with --plugin-updates. Returns { currentVersion, update, upToDate, requirements[], extensions[], summary, blockers[], notes[] }.

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3/5.0

    Scored across 38 tools

    Disambiguation4/5

    Most tools have clearly distinct resource/action targets, and descriptions explicitly differentiate close pairs like products_search vs storefront_search, orders_search vs orders_get, and the various diagnostic tools. There is some overlap among shop_brief, shop_pulse, shop_audit, shop_diagnose, and entity_search vs dedicated tools, but the boundaries are usually explained well enough.

    Naming Consistency3/5

    All names use snake_case, but the convention is mixed: many follow resource_action (orders_search, customers_get), while others are noun_noun or verb-first (order_history, checkout_simulate, update_check, sales_report). Singular/plural is inconsistent too (orders_* vs order_history, order_documents_list), though names remain readable.

    Tool Count2/5

    38 tools is heavy for a single server and well above the typical coherent range. The broad Shopware admin domain justifies many operations, but the surface still feels sprawling and would benefit from consolidation, especially around diagnostics, reporting, and entity escape hatches.

    Completeness3/5

    Read/analysis coverage is strong across products, orders, customers, promotions, stock, checkout, reporting, and diagnostics, but the lifecycle is almost entirely read-only. There are no create/update/delete operations for products, orders, customers, promotions, or settings, which is a notable gap for a general shop-management server.

    Maintenance

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables MCP clients to work with one or many Horoshop stores through the public API, control panel and storefront cart — reading and updating the catalog, processing orders, managing SEO, redirects, marketplace feeds, design and settings. Write operations preview changes by default, require confirmations for bulk or irreversible actions, and verify results by reading them back.
      1
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI assistants to manage Magento 2 / Adobe Commerce products, stock, orders, and customers through 12 read/write MCP tools with secure, audited access.
      AGPL 3.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      Connects MCP-compatible clients to a Shopify store's Admin GraphQL API, exposing products, orders, customers, inventory, and sales data as callable tools. It enables natural-language store queries, low-stock and sales summaries, customer support answers, and creation of draft products for review.
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables MCP clients to run one or more WooCommerce stores through the REST API: browsing the catalog, working through orders, issuing refunds, adjusting prices and stock in bulk, and reading sales analytics. Every write is previewed before it is applied and can be recorded to an audit log.
      136 npm
      1
      MIT