DEV Community: Ievgenii Gryshkun

Magento AI Brand Visibility: Does ChatGPT Recommend Your Store?

Ievgenii Gryshkun — Sat, 13 Jun 2026 07:17:29 +0000

Note: set published: true when you're ready. The canonical_url above tells Google the original lives on angeo.dev, so this cross-post won't compete with it. Replace cover_image with the uploaded featured image URL.

Short answer: when your customers ask ChatGPT, Claude or Perplexity "where should I buy this?", you currently have no idea whether your store appears in the reply. Angeo AEO Brand Visibility is a free, open-source Magento 2 module that measures exactly that: it runs brand-probing prompts across the five major AI models and scores your real-world AI brand visibility from 0 to 100.

Search no longer means only Google. More buying research now starts inside an AI assistant that returns one synthesized answer naming a few stores. AI Engine Optimization (AEO) is the work of making sure your brand is one of those names — and this module tells you, in minutes, whether it is.

Why AI brand visibility matters for Magento merchants

AI answers are winner-takes-most. Where a search results page lists ten links, an AI assistant usually names two or three stores. If you're not in that shortlist, you're invisible to that buyer — there is no "page two". Traditional SEO tools can't see this: they measure rankings, backlinks and crawl health, not what a model actually says when prompted. That blind spot is what AEO Brand Visibility closes.

How Magento AI brand visibility tracking works

You set your brand name, domain, category and a few top products. The module sends natural shopping prompts — "What are the best online stores to buy {category}?", "Tell me about {brand}", "Compare {brand} with similar stores" — to every enabled AI provider. Each response is analysed for five signals, scored, cached and saved to a history log so you can watch the trend over time.

Supported AI providers

Provider	Why it's included	Free tier?
ChatGPT (OpenAI)	The most-used assistant; the default benchmark for AI recall.	No
Claude (Anthropic)	Strong reasoning; common for research-style queries.	No
Perplexity	Live web search — best signal for what the internet says about you now.	No
Gemini (Google)	Tied into Google's ecosystem; generous free tier.	Yes
Groq	Fast, free Llama hosting — ideal for zero-cost testing.	Yes

Start with the free providers (Gemini and Groq) to validate your setup at zero cost, then add paid providers for the most commercially relevant picture.

The five visibility signals

Mentioned — your brand or a configured alias appears anywhere in the answer.
Recommended — the model actively suggests you (recommendation language near your mention, or you appear in a ranked list).
URL cited — your domain is referenced in the response, the strongest trust signal.
First result — you appear in the first quarter of the answer, i.e. top-of-mind.
Positive sentiment — favourable language sits close to your mention.

Each signal is weighted and combined into a single 0–100 score with an A–F grade.

What you get in the Magento admin

Run Audit — one click queries every enabled model and shows live scores, per-provider chips and signal rates.
Statistics & trend chart — average, best and worst scores plus a score-over-time graph from your fresh (non-cached) runs.
Audit History — your recent runs, each expandable to the full prompt-by-prompt detail.
Action Plan — a prioritised, time-bounded roadmap of what to fix first.
Single Query Tester — send one prompt to one provider and inspect the raw response.

Automate it: CLI, cron and CI gates

AI brand visibility drifts as content, reviews and the web change, so the module ships a CLI command and a cron job — and it can fail a CI build if your score drops below a threshold.

# Run a full audit across all enabled providers
bin/magento angeo:aeo:brand-visibility

# Force fresh queries (bypass the cache)
bin/magento angeo:aeo:brand-visibility --refresh

# Test a single provider / prompt
bin/magento angeo:aeo:brand-visibility --provider=perplexity --prompt=brand_direct

# Machine-readable output for dashboards
bin/magento angeo:aeo:brand-visibility --format=json

# Gate a pipeline: exit 1 if the score falls below 60
bin/magento angeo:aeo:brand-visibility --fail-on=60

Built to extend angeo/module-aeo-audit

AEO Brand Visibility plugs into angeo/module-aeo-audit as a live-signal checker, sitting alongside the 15 built-in technical checks (robots.txt, llms.txt, structured data and more). Your brand-recall score becomes part of the same unified AEO report — one command, one dashboard, technical and real-world signals together.

Security & privacy

Provider API keys are stored with Magento's encrypted backend model and never written to logs. Outbound calls are HTTPS-only and don't follow redirects, admin endpoints are protected by ACL and form keys, and all AI-provider text is escaped before rendering. Serialization uses Magento's SerializerInterface throughout.

Installation

composer require angeo/module-aeo-brand-visibility
bin/magento setup:upgrade
bin/magento setup:di:compile
bin/magento cache:flush

Then open Stores → Configuration → Angeo AEO → Brand Visibility, add at least one provider API key, set your brand name and domain, and hit Run Audit.

How to improve your AI brand visibility score

Low mention rate? Publish an llms.txt file (angeo/module-llms-txt) and keep your store name consistent across every page.
Domain not cited? Strengthen backlinks and reference your canonical URL in structured data and llms.txt.
Not being recommended? Improve product content quality and implement review schema.
Appearing late in answers? Build topical authority with category-focused content.

FAQ

Is the module free? Yes — MIT licensed. You only pay for the AI provider usage you choose, and you can run it entirely free using the Gemini and Groq free tiers.

Which AI models does it check? ChatGPT, Claude, Perplexity, Gemini and Groq. Enable any combination.

Will audits cost a lot in API fees? Not if configured sensibly. Results are cached, you control how many prompts run, and total queries equal enabled providers × active prompts.

What Magento versions are supported? 2.4.6, 2.4.7 and 2.4.8 (Adobe Commerce and Mage-OS), PHP 8.2–8.4. Requires angeo/module-aeo-audit v3.0+.

How is this different from SEO tools? SEO tools measure rankings and crawlability. This measures what AI assistants actually say when asked shopping questions.

AI assistants are already recommending stores in your category — the only question is whether they're recommending you. Install angeo/module-aeo-brand-visibility, run your first audit, and find out in minutes. You can also run a free 30-second AEO audit.

Originally published at angeo.dev.

The 4-Layer Magento 2 AEO Stack: Making Your Store Visible to ChatGPT, Claude & Gemini (2026)

Ievgenii Gryshkun — Sat, 06 Jun 2026 19:06:09 +0000

I've written here before about fixing robots.txt for the AI bots and checking your store's ChatGPT visibility with a free audit module. This post zooms out and puts the whole thing in one place: the four layers that decide whether an AI assistant can find, trust, and recommend your Magento store — and the honest data on which layers actually matter in 2026.

Default Magento 2 typically scores around 23% on an AEO audit across the stores I've measured. Not because anything is broken — because every one of these signals ships off by default and nobody flipped them on.

Here's the stack, in priority order.

Layer 1 — robots.txt: you're probably blocking the bots you want

The most common failure, and almost always accidental. A robots.txt written for Google in 2019 says nothing about the AI fleet, and some security/hardening configs block unknown bots — which now includes the crawlers feeding ChatGPT, Claude, Gemini, and Perplexity.

There's no single user-agent to allow. In 2026 you're dealing with ~10 distinct AI bots across four platform families. Minimal explicit allow-list:

User-agent: GPTBot
Allow: /

User-agent: OAI-SearchBot
Allow: /

User-agent: ChatGPT-User
Allow: /

User-agent: ClaudeBot
Allow: /

User-agent: PerplexityBot
Allow: /

User-agent: Google-Extended
Allow: /

Sitemap: https://yourstore.com/sitemap.xml

Key gotcha: Google-Extended is not Googlebot. Blocking it doesn't touch your Google ranking — it only governs whether Google's AI products may use your content. Tons of sites blocked it during the 2023–24 anti-scraper panic and never revisited. If you want AI visibility, reconsider it.

Highest-leverage 20 minutes in the whole stack. Do it first.

Layer 2 — JSON-LD: Magento ships the wrong format and skips the one field that matters

This one is Magento-specific and it's the difference between being eligible for AI Shopping answers and being silently dropped.

Default Magento 2 outputs product structured data as microdata, not JSON-LD. AI extraction systems strongly prefer JSON-LD — a clean, self-contained block they can parse without reconstructing meaning from scattered HTML attributes.

And the field that quietly kills you:

offers.availability is frequently missing — and ChatGPT Shopping will skip a product with no availability signal entirely.

From the model's side, it's assembling a purchasable recommendation. A product it can't confirm is in stock is a liability, so it drops it. No warning. You just don't appear.

Correct, AI-friendly block:

<script type="application/ld+json">
{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Pre-Seasoned Cast Iron Skillet 12\"",
  "sku": "CAST-SKILLET-12",
  "brand": { "@type": "Brand", "name": "YourBrand" },
  "offers": {
    "@type": "Offer",
    "url": "https://yourstore.com/cast-iron-skillet-12",
    "priceCurrency": "EUR",
    "price": "59.00",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "reviewCount": "212"
  }
}
</script>

Three traps:

Don't inject schema via GTM. AI crawlers generally don't execute JavaScript, so tag-manager-injected schema is invisible to them even though it validates in DevTools. It must be server-rendered.
Hyvä themes ship with zero product schema by default — neither microdata nor JSON-LD. If you migrated to Hyvä for speed, you may have silently dropped your structured data. Check now.
Bind availability to real stock, never a hardcoded InStock. A model that recommends your out-of-stock item once learns to distrust your feed.

Verify it's in the raw HTML (no JS):

curl -s https://yourstore.com/your-product | grep -A30 'application/ld+json'

Nothing returned = the AI layer sees nothing.

Layer 3 — llms.txt: ship it, but not for the reason you've been sold

llms.txt is a Markdown file at your root giving AI systems a curated map of your store — to LLMs what robots.txt is to crawlers, but editorial rather than access-control.

Now the honest part. The "llms.txt boosts your AI rankings" pitch isn't supported by 2026 data:

A 300k-domain study found ~10% adoption; among the 50 most AI-cited domains, only one had the file.
One vendor logged 62,100 AI bot visits over 90 days — 84 hit llms.txt. That's 0.1%. Another tracking 500M+ bot events found GPTBot, ClaudeBot, PerplexityBot, OAI-SearchBot and Google-Extended overwhelmingly skip it and crawl HTML directly.
OpenAI, Anthropic, and Perplexity haven't committed to reading it automatically.

So why ship it? Because it's a Business-to-Agent (B2A) play, not an SEO play. Agentic and IDE-style tooling already fetches it, agentic commerce is heading the same way, and conventions like this often get published before platforms formally commit (robots.txt predated official search-engine support). It's half a day of cheap insurance.

# YourStore

> Premium cast iron and carbon steel cookware. EU-based, ships across Europe,
> 30-day returns, mid-range pricing.

## Categories
- [Cast Iron Skillets](https://yourstore.com/cast-iron)
- [Dutch Ovens](https://yourstore.com/dutch-ovens)

## Buying Guides
- [Cast iron vs carbon steel](https://yourstore.com/guides/cast-vs-carbon)

## Policies
- [Shipping & Returns](https://yourstore.com/shipping)

Ship it, spend the half day, then stop optimizing it and put your energy into Layers 1, 2, and 4. And remember: a stale llms.txt is worse than none — wrong stock claims train models to distrust you.

Layer 4 — ACP & UCP: the part that's actually about money

The 2026 shift bigger than schema tweaks: AI is moving from discovery ("here are some pans") to transaction ("I bought the pan for you"). Two protocols define that layer, and Magento merchants — unlike Shopify merchants — wire it up themselves.

ACP (OpenAI + Stripe) — live in ChatGPT since late 2025; settled into a discovery-and-feed role. You submit a spec-compliant feed, ChatGPT surfaces products, checkout uses delegated single-use payment tokens, with a transaction fee on completed Instant Checkout orders.
UCP (Google + Shopify + 20-plus partners incl. Walmart, Target, Visa, Mastercard) — announced at NRF Jan 2026, expanded at Google Marketing Live in May. Broader, protocol-agnostic (REST, MCP, A2A), spanning discovery → cart → checkout → post-purchase across Google AI Mode, Gemini, YouTube, Gmail. Agents discover capabilities via /.well-known/ucp.

Reality check:

It's not "pick one." They target different agent ecosystems; dual-protocol merchants reportedly see meaningfully more agentic traffic.
Most groundwork is shared — clean schema, an accurate live feed, defined shipping/return/pricing policies are prerequisites for both and survive any spec reshuffle (ACP already pivoted away from native checkout once).
Sensible Magento order: solid Layers 1–3 → ship ACP feed → prepare UCP manifest.

Shopify gets much of this by partnership default. Magento/Adobe Commerce: you own the stack — full control, full responsibility.

TL;DR priority order

Fix robots.txt so the AI fleet can crawl you. (~20 min, highest leverage)
Emit server-rendered JSON-LD with a live offers.availability. (Hyvä users: confirm you have any schema.)
Verify with no-JS curl. Not in raw HTML = invisible.
Ship llms.txt as cheap B2A insurance, then leave it.
Build the shared commerce substrate, attach ACP, then UCP.

Google decides whether you rank. AI engines increasingly decide whether you exist in the answer. Two separate jobs now.

The open-source modules behind this (AEO audit CLI, llms.txt generator, multi-store AI description tooling) are on Packagist and documented at angeo.dev. The llms.txt and ACP/UCP figures come from independent 2026 studies — verify current spec versions as you implement, this area moves monthly.

If you've pulled your own AI-bot server logs on a Magento store, drop the numbers in the comments — real crawler data is still scarce and I'd like to compare.

llms.txt for Magento 2: Free vs Paid Modules (2026 Review)

Ievgenii Gryshkun — Mon, 01 Jun 2026 07:06:32 +0000

This is a cross-post. The original — with the full module-by-module comparison table, feature breakdown, and FAQ — is on angeo.dev.

AI systems are increasingly shaping how users discover products.

Instead of browsing category pages, users now ask:

"best hiking boots under €150"

and get a synthesized answer immediately.

This shift creates a new problem for eCommerce: your store content is no longer consumed only as HTML. llms.txt is an attempt to provide AI systems with a cleaner, structured summary of a website.

TL;DR

Multiple Magento 2 llms.txt solutions exist (free and paid)
Differences are mostly about workflow, not output quality
There is no confirmed evidence that llms.txt impacts search rankings
Value comes from better AI interpretation of store structure
JSONL-style structured feeds may become more important long-term

Why this matters

Modern LLM-based assistants compress pages, reconstruct product context, and may misinterpret or ignore important catalog structure.

This can lead to:

outdated product descriptions in AI answers
missing categories
incorrect pricing context

llms.txt tries to reduce that ambiguity by providing a simplified representation of the store.

What is llms.txt?

A llms.txt file is a Markdown-based endpoint typically located at:

https://yourstore.com/llms.txt

It can include:

store overview
category links
product references
policies and informational pages

It is not a formal standard and is still evolving.

llms.txt vs sitemap.xml vs robots.txt

File	Purpose	Consumers
robots.txt	crawler rules	search engines, bots
sitemap.xml	URL discovery	search engines
llms.txt	content summary	AI systems (varies)

These are complementary layers, not replacements.

Does it improve SEO?

There is no verified evidence that llms.txt directly influences Google rankings.

Its impact is more likely indirect:

clearer AI summaries
more consistent product descriptions in LLM outputs
reduced hallucination risk in catalog interpretation

Magento 2 implementation approaches

In practice, implementations fall into three categories.

1. Manual file (small stores)

Simple Markdown file maintained by hand. Works well when:

catalog changes rarely
under 50–100 products
no automation required

2. Admin-driven modules (business teams)

Paid extensions usually add an admin UI, content selection controls, scheduling (cron), and multi-store support. Useful when marketing teams manage content directly.

3. Developer / automation-driven modules

Open-source or CLI-based tools typically provide CLI generation, cron updates, and JSONL output in some cases. This approach fits dynamic catalogs better.

For the full feature-by-feature comparison of specific paid and free modules (Magedelight, Webkul, Plumrocket, Eleventex, Magefan, and the open-source option), see the complete comparison table on angeo.dev.

Example structure

A typical llms.txt might look like:

# Store Name

## Categories
- Hiking: https://store.com/hiking
- Climbing: https://store.com/climbing

## Featured Products
- Trail Boot X3 — €149 — waterproof hiking boot
- Summit 40L Pack — €89 — lightweight backpack

## Policies
- Shipping: EU delivery 2–3 days
- Returns: 30 days

What surprised me during research

A few observations stood out:

Most vendor implementations are structurally very similar
Marketing differences are larger than technical differences
JSONL-style structured output is rarely implemented, despite being more machine-friendly
There is still no confirmed adoption standard among major AI platforms

In other words: the ecosystem is early and still converging.

Key takeaway

For most Magento stores:

You don't need a complex solution to start
Manual or lightweight generation is often enough
Automation only matters at scale or high change frequency

The real long-term value is not the file itself, but how consistently your product data is structured for machines.

Final thought

llms.txt should not be treated as a magic SEO layer. It is better understood as:

a compatibility layer between eCommerce content and AI systems

Whether it becomes important depends less on Magento and more on how AI platforms evolve ingestion of structured web data.

Full comparison with module table, pricing, and FAQ: angeo.dev/llms-txt-magento-2-free-vs-paid-module-comparison/

Shopify vs Magento for AI Commerce in 2026: Platform-Mediated vs Merchant-Controlled AEO

Ievgenii Gryshkun — Thu, 28 May 2026 16:16:18 +0000

In March 2026, Shopify positioned its eligible merchants for default discovery inside ChatGPT via Agentic Storefronts — no per-merchant setup required. Two months later, the same week Shopify reported its fastest quarterly revenue growth in four years, the stock fell 16%.

Both facts are true. They describe where AI commerce actually sits in 2026: infrastructure that is genuinely transformative, deployed into a market uncertain whether the near-term economics hold.

For developers and architects working with Adobe Commerce, Magento 2, or any non-Shopify e-commerce stack, the question is narrower than the stock story: which architecture gives the merchant the most controllable path to AI commerce visibility — and what does the implementation actually look like in code?

This article frames the answer through a single distinction: platform-mediated AI distribution (Shopify's bet) versus Merchant-Controlled AEO (the approach Magento merchants build themselves, and increasingly the more defensible long-term position).

Read the full version with embedded diagrams on angeo.dev.

Key findings (as of May 2026)

Shopify wins distribution. Agentic Storefronts positioned millions of merchants for default ChatGPT visibility in March 2026 — onboarding effort is near-zero for eligible US merchants.
Magento wins control. A default Adobe Commerce install scores ~25% on a 9-signal AEO audit. With free open-source modules, 80–90% is achievable in approximately 90 minutes.
Both reach the same AI channels. ChatGPT, Microsoft Copilot, Google AI Mode, Gemini, and Perplexity are technically accessible from either platform.
Retrieval quality is platform-agnostic. JavaScript-rendered content is invisible to AI extraction on both Shopify and Magento by default. The Agentic Commerce Protocol (ACP) feed solves discovery; it does not solve on-page extraction.
Auditability differs sharply. Magento's AEO signals are inspectable with one CLI command. Shopify's distribution layer is largely opaque to the individual merchant.
Multi-store and B2B favor Magento. Per-store-view AEO configuration, B2B price books, and ERP integration remain Magento-native territory.

TL;DR — Shopify wins distribution. Magento wins control. Both reach the same AI channels. The platform choice matters less than the AEO implementation you build on top of it.

The two paths to AI commerce visibility

The fundamental difference between the two platforms is architectural, not cosmetic:

SHOPIFY — Platform-Mediated AI Distribution
Merchant catalog
       ↓
Shopify Catalog (platform-managed)
       ↓
Agentic Commerce Protocol (ACP) syndication
       ↓
OpenAI / Microsoft Copilot / Google AI Mode / Gemini
       ↓
AI recommendation

MAGENTO — Merchant-Controlled AEO
Merchant catalog
       ↓
robots.txt — OAI-SearchBot, PerplexityBot, Google-Extended access
llms.txt — machine-readable catalog map
Product JSON-LD schema (with offers.availability)
ACP product feed (generated locally)
MCP server endpoints (live agent access)
Server-rendered content (extractable by AI crawlers)
       ↓
AI crawler access + retrieval + feed ingestion
       ↓
AI recommendation

Shopify handles the distribution layer on the merchant's behalf. Magento exposes the full stack — each signal configured, testable, and auditable by the merchant.

Neither path is inherently superior. They reflect different philosophies about who controls the infrastructure between a merchant and an AI platform.

The state of play: what each platform delivers

Shopify — platform-mediated AI distribution

Shopify's AI commerce strategy is the most significant platform-level AEO development of 2026. Via Agentic Storefronts, Shopify positioned its merchant ecosystem for default discovery inside ChatGPT, Microsoft Copilot, Google AI Mode, and the Gemini app — managed centrally from the Shopify Admin, with no app installation or separate feed submission required from merchants.

The architecture is technically significant: Shopify describes syndicating real-time pricing, inventory, images, and variants from the Shopify Catalog to OpenAI's shopping layer via the Agentic Commerce Protocol (ACP). Per Shopify's announcements, merchants who had done nothing specific for AI visibility were positioned for product discoverability inside ChatGPT by default — though actual retrieval consistency and ranking behaviour within ChatGPT's shopping layer are not independently verified.

Shopify has also announced native Model Context Protocol (MCP) server support via its AI Toolkit — described as enabling AI agents to access live store data including inventory and specifications. Production MCP adoption in commerce is still early-stage, but the infrastructure appears designed for that direction as the ecosystem matures.

Early reported metrics suggest meaningful traction: Shopify reported AI-driven traffic surging 8× year-over-year in Q1 2026, with orders from AI-powered searches up nearly 13× — from a small but growing base.

What this means: A US-based DTC merchant on Shopify who has done literally nothing for AEO is positioned for ChatGPT visibility by default. That is unprecedented for the SMB segment.

Magento — Merchant-Controlled AEO

Adobe Commerce / Magento 2 has no equivalent platform-level arrangement with OpenAI or other AI platforms. Every AEO signal must be configured deliberately. The default Magento 2 installation scores approximately 25% on a 9-signal AEO audit — based on audits across 50+ stores — with three consistent failure points:

robots.txt blocks AI crawlers — default wildcard rules prevent OAI-SearchBot, PerplexityBot, and Google-Extended from accessing the store
No llms.txt — no machine-readable catalog map is present
Product schema missing offers.availability — required field for ChatGPT Shopping ACP conformance checks

Fixing these takes approximately 90 minutes with the right open-source modules. Reaching ChatGPT Shopping eligibility requires a separate application at chatgpt.com/merchants, ACP feed generation, and passing OpenAI's conformance review. There is no automatic path — but the same AI commerce channels are technically reachable through Merchant-Controlled AEO implementation.

What this means: Magento's "disadvantage" is the cost of one afternoon. The "advantage" is that you own and can audit every signal in the stack — which matters more as AI platforms diversify and feed terms evolve.

Real audit output — what Merchant-Controlled AEO looks like

The abstract comparison becomes concrete when you see what the audit actually returns. Here is the output from bin/magento angeo:aeo:audit on a fully configured Adobe Commerce 2.4.7 store (mid-market apparel, ~14k SKUs, EU multi-store):

$ bin/magento angeo:aeo:audit --store=default

Running AEO audit for store: default
─────────────────────────────────────────────────────────────

✓ PASS  robots.txt              All 10 AI bots permitted
                                  OAI-SearchBot, ChatGPT-User, GPTBot,
                                  PerplexityBot, Google-Extended,
                                  ClaudeBot, Claude-Web, Bingbot,
                                  CCBot, Applebot-Extended

✓ PASS  llms.txt                Generated — 12,400 products mapped
                                Last regenerated: 2026-05-24 03:00 UTC
                                Per-store-view: 4 variants active

✓ PASS  Product JSON-LD         offers.availability present
                                aggregateRating present (8,200 / 12,400)
                                brand, sku, gtin13 present
                                priceValidUntil present

✓ PASS  ACP product feed        Spec-compliant — 12,400 products
                                Refresh interval: 15 min
                                Last successful sync: 2026-05-25 09:15 UTC
                                OpenAI conformance: PASSED 2026-04-12

✓ PASS  MCP server endpoint     /mcp/v1 active
                                Live inventory + pricing exposed
                                Authentication: bearer token configured

✓ PASS  Server-side rendering   Product description visible in HTML
                                No JavaScript-only critical content

✓ PASS  FAQPage schema          On 8 CMS pages
                                Average 6 Q&A pairs per page

✓ PASS  AI order attribution    sales_order.ai_referrer column active
                                Q1 2026: 1,847 orders attributed
                                Top source: ChatGPT (62%)

⚠ WARN  Canonical consistency   3 product URLs with conflicting hreflang
                                See: var/log/angeo_aeo_warnings.log

─────────────────────────────────────────────────────────────
AEO Score: 91% — Excellent
Time elapsed: 4.2s

On Shopify, AI visibility is largely a black box. You can observe whether products appear in ChatGPT responses. You cannot inspect what offers.availability value Shopify is transmitting for a specific variant via ACP, verify the exact feed format OpenAI is receiving, or audit which products are failing conformance checks and why. If a product is not appearing, the debugging path is indirect.

That difference — a 4-second CLI output versus an opaque distribution layer — is what "Merchant-Controlled AEO" means in practice.

Retrieval tests — what AI engines actually surface

The capability tables describe theoretical reach. Retrieval tests describe what AI engines actually do with the available signals. These are spot-check results from controlled queries run in May 2026 across three store configurations in the same category (industrial test equipment, identical product catalogs replicated across platforms for benchmarking purposes):

Query	Shopify (Agentic SF)	Magento (default)	Magento (Merchant-Controlled AEO)
"best Siemens thermal imaging camera under €2k"	Surfaced — product card	Absent	Surfaced — product card + spec citation
"Fluke 87V vs Keysight U1242C"	Surfaced — comparison	Absent	Surfaced — citation in editorial answer
"thermal camera with USB-C and 320×240 sensor"	Partial — generic recs	Absent	Surfaced — exact-spec match
"recommend a megohmmeter for industrial use"	Surfaced — top 3	Absent	Surfaced — top 3 with cited specs
"who sells calibrated multimeters in the EU"	Partial — US-bias	Absent	Surfaced — EU retailer cited

ChatGPT retrieval spot-checks, May 2026. Same catalog across configurations. Results are illustrative of architectural difference, not exhaustive ranking benchmarks. AI retrieval is non-deterministic; individual query outcomes vary across sessions.

Two observations from the test pattern:

Default Magento is invisible. Blocked AI bots, missing llms.txt, incomplete schema, and no ACP feed compound into zero retrieval surface.
Configured Magento matches Shopify on retrieval — and sometimes exceeds it on EU-specific and spec-driven queries. Agentic Storefronts is currently US-weighted. Detailed spec retrieval depends on schema depth, which Magento exposes more granularly than Shopify's standard product templates.

What this means: The distribution-versus-control framing is not theoretical. Once a Magento store is configured with Merchant-Controlled AEO, retrieval performance is competitive — and the merchant retains diagnostic control Shopify does not provide.

Full capability comparison

Capability	Shopify	Magento (configured)	Magento (default)
ChatGPT Shopping (ACP)	✅ Platform-level via Agentic Storefronts	✅ Manual — ACP feed + application	✗ Not configured
Perplexity discovery	✅ Via Shopify Catalog integration	✅ Via llms.txt + PerplexityBot access	✗ Bot blocked by default
Google AI Mode / Gemini	✅ Via Agentic Storefronts opt-in	✅ Via Google Merchant Center + Google-Extended access	⚠ Partial
Microsoft Copilot	✅ Active integration	⚠ Requires custom ACP feed configuration	✗
MCP (Model Context Protocol) live agent access	✅ Native in Shopify Admin	✅ Via angeo/module-openai-product-feed-api	✗
llms.txt	⚠ No native generation	✅ angeo/module-llms-txt — per store view	✗
Product JSON-LD schema	✅ Better defaults than Luma — incomplete for full ACP compliance	✅ angeo/module-rich-data — availability, aggregateRating	⚠ Missing offers.availability
AI order attribution	✅ Native in Shopify Analytics	⚠ Requires custom observer to persist to sales_order	✗ GA4 dark traffic only
robots.txt AI bot access	✅ Managed by Shopify	✅ angeo/module-robots-txt-aeo	✗ Blocked by default
Multi-store / B2B / custom data	⚠ Limited without Shopify Plus	✅ Native — multi-store, B2B, ERP integration	✅ Same
AEO audit CLI	⚠ No CLI audit — manual checking only	✅ angeo/module-aeo-audit — 9 signals, one command	✅ Same

Where Shopify's advantage is real

Platform-level distribution via ACP

The Shopify–OpenAI partnership, based on public announcements, is a structural distribution advantage — not a parity feature. Per Shopify's documentation, eligible merchants were positioned for default ChatGPT discoverability through Agentic Storefronts and the Agentic Commerce Protocol without individual action. No equivalent arrangement exists for Adobe Commerce or Magento merchants. Adobe has not announced a comparable platform-level integration with any AI shopping platform.

Native AI attribution

Shopify Analytics natively filters sessions and orders by AI referrer. For Magento, even basic AI attribution requires custom observer code to persist referrer data to sales_order. The measurement infrastructure Shopify includes by default takes several hours of custom development on Magento.

Speed to AI visibility

For a merchant starting from zero, Shopify's path to AI commerce visibility is measured in hours — or zero, given Agentic Storefronts default activation. For Magento, the path requires sequential steps: AEO audit, robots.txt fix, llms.txt generation, schema update, ACP feed generation, merchant application, and OpenAI conformance review. Total elapsed time: days to weeks.

The Shopify thesis in one sentence: If you accept platform-mediated AI distribution, Shopify delivers it faster and more completely than any alternative on the market.

Where Magento's advantage is real

Control and auditability — the Merchant-Controlled AEO position

Every AI signal in Magento's AEO stack is explicitly configured, testable, and auditable with a single CLI command (see the audit output above). On Shopify, AI visibility is largely a black box. You can observe whether products appear in ChatGPT responses. You cannot inspect what ACP feed payload Shopify is transmitting for a specific variant, verify the exact format OpenAI is receiving, or audit which products are failing conformance checks and why.

Multi-store architecture

Shopify's AI capabilities are primarily designed for single-brand storefronts. For merchants running multiple stores with different catalogs, languages, currencies, or B2B price books — Magento's native multi-store architecture provides per-store control over every AEO signal. Separate llms.txt per store view, different schema configurations per locale, precise ACP feed control per market.

Open standards, no vendor lock-in

The signals Merchant-Controlled AEO is built on are open standards:

robots.txt — 30-year-old RFC
JSON-LD — W3C standard
Agentic Commerce Protocol (ACP) — OpenAI's open spec, adoptable by any merchant
Model Context Protocol (MCP) — Anthropic's open spec
llms.txt — emerging community convention

A merchant running Merchant-Controlled AEO reaches any AI engine that speaks these protocols — present and future. A merchant on Shopify reaches the platforms Shopify has agreements with. The first scales with the protocol layer; the second scales with the platform's BD team.

Data ownership

When a Shopify merchant uses Agentic Storefronts, their product data — pricing, inventory, variant configuration — flows through Shopify's infrastructure to AI platforms via ACP. The merchant does not control the update frequency beyond what Shopify allows, or verify the representation of their products in AI responses. On Magento, the ACP feed is generated locally, validated locally, and transmitted directly. The merchant controls exactly what AI platforms receive.

The Magento thesis in one sentence: If you want to own the infrastructure between your catalog and AI platforms — and audit it — Merchant-Controlled AEO on Adobe Commerce is the only mainstream option that delivers it.

The gap neither platform fully solves

Both Shopify and Magento share a structural limitation independent of platform choice: JavaScript rendering.

AI extraction systems do not reliably execute client-side rendering. Shopify's standard product themes use JavaScript for variant selection and dynamic content. Magento's Luma theme uses RequireJS tabs that collapse the product description on load.

In both cases, content hidden behind JavaScript is often invisible to AI extraction pipelines — regardless of how comprehensive the ACP structured data feed is. The feed provides product data for shopping interfaces; crawled page content provides context for retrieval and editorial recommendations. Both matter. Agentic Storefronts solve the feed discovery problem. They do not solve the on-page extraction problem for content-based AI visibility.

Which platform for which merchant

Merchant profile	Better fit	Primary reason
DTC brand, <10k SKUs, US market, speed priority	Shopify	Agentic Storefronts positions catalog for ChatGPT by default via ACP
Multi-store, multi-language, EU / APAC primary	Magento	Per-store AEO configuration; Shopify AI features US-first
B2B manufacturer or distributor	Magento	Complex catalog depth, B2B pricing, ERP integration
Mid-market brand, existing Shopify store	Shopify	Native AI attribution, ACP feed management, Copilot integration live
Enterprise Adobe Commerce, technical team	Magento (Merchant-Controlled AEO)	Data ownership, auditability, custom AEO implementation

The real shift isn't Shopify vs Magento

The platform debate is the surface. The deeper question — the one that will define commerce infrastructure for the next decade — is whether AI commerce becomes platform-mediated or merchant-controlled.

Shopify is betting on centralized AI distribution. Agentic Storefronts, native ACP syndication, Shopify-managed MCP endpoints, AI attribution baked into Shopify Analytics — every piece reinforces a single architectural premise: the platform sits between the merchant and the AI layer, and that is the value proposition.

Adobe Commerce / Magento 2 still allows direct infrastructure ownership. The ACP feed is generated locally. The MCP server runs on the merchant's stack. The llms.txt is regenerated by the merchant's cron. The AEO audit is the merchant's CLI command. Every signal in the AI commerce pipeline is the merchant's to inspect, change, version-control, and migrate.

For SMB DTC, platform-mediated distribution is probably the right trade. The merchant gets ChatGPT visibility without learning ACP. Shopify takes the operational complexity.

For mid-market and enterprise — especially merchants with multi-store architecture, B2B obligations, regulatory locality requirements, or strategic catalog data that should not transit through a third-party distribution layer — Merchant-Controlled AEO is increasingly the more defensible position. Not because Shopify's offering is weak, but because the value of owning the infrastructure between your catalog and the AI layer grows as that layer becomes more economically significant.

Shopify won the first round of AI commerce distribution. The second round — retrieval quality, content accuracy, citation authority, attribution measurement, multi-channel feed control — is more level, and increasingly favors merchants who can own and audit their stack.

In 2026, the choice between platform-mediated AI distribution and Merchant-Controlled AEO is more consequential than the choice between storefront features themselves.

This article was originally published on angeo.dev with embedded architecture diagrams and AEO score progression charts. The angeo/module-aeo-audit checks all 9 Merchant-Controlled AEO signals for Adobe Commerce / Magento 2 stores in one CLI command.

Adobe Commerce Cloud now costs $40k/year. We migrated from Adobe Commerce to Magento Open Source — here's the honest breakdown

Ievgenii Gryshkun — Mon, 25 May 2026 19:47:11 +0000

Adobe Commerce Cloud licence pricing crossed $40k/year in 2026 for many mid-market merchants. Three of our clients hit that wall over the past 14 months and asked the same question: is migrating to Magento Open Source actually worth it?

We ran all three migrations. Two were worth it. One wasn't.

This is the honest version of that story — including the database schema gotchas, the B2B Suite trap, and the cost math nobody puts in marketing posts.

TL;DR

Migration saves $100k-250k over 5 years IF you don't depend on Adobe-only features
B2B Suite, Adobe Sensei, and staging features are the three biggest dependency traps
The row_id vs entity_id schema difference will break custom modules that bypass Repository pattern
Two-thirds of mid-market merchants pay for features they don't use — the other third critically depend on them
Open Source is the same Magento 2 framework. What changes is the licensing, infrastructure, and a handful of proprietary modules.

Why this conversation is happening now

For years Adobe Commerce Cloud was the "safe" choice for mid-market merchants doing $1M-$10M GMV. You paid the license, you got hosting + auto-deploys + B2B + AI recommendations + Adobe's support, and you didn't have to think about infrastructure.

That math is shifting in 2026:

License pricing has climbed steeply (we've seen $22k → $40k+ jumps on renewal)
Adobe's roadmap focus has shifted toward Adobe Experience Manager integrations, not core Commerce features
The Hyvä ecosystem has reached production maturity on Open Source
Self-managed hosting (Hypernode, MGT, Cloudways) is now operationally as smooth as Adobe Cloud was three years ago

The merchants asking us about migration aren't doing it to save $10k. They're doing it because Adobe's value proposition no longer matches what they need.

What actually stays the same

Both platforms share the Magento 2 core. If your team works in Magento daily, this part doesn't change:

Module structure and DI XML
GraphQL schema and REST API
Composer-based dependency management
Admin layout and UI components
Frontend stack (Luma, Hyvä, PWA Studio, custom headless — all work either way)
bin/magento CLI commands

This is why "migration" is a misleading word. You're not moving to a different platform. You're removing the Adobe layer from the same platform.

What actually breaks — the technical reality

This is where I disagree with most write-ups on this topic. The migration is not "smooth" or "straightforward." It has specific failure modes, and pretending otherwise leads to blown timelines.

1. The `row_id` vs `entity_id` schema split

Adobe Commerce uses row_id in catalog tables (catalog_product_entity, catalog_category_entity) to support staging and preview features. Open Source uses entity_id.

If your codebase has SQL that queries these tables directly — instead of going through Magento's Repository pattern — those queries silently break:

// Will break after migration
$connection->query("SELECT * FROM catalog_product_entity WHERE row_id = $id");

// Will keep working — uses repository pattern
$product = $this->productRepository->getById($id);

Across three projects we found ~40 places where developers had bypassed Repository for "performance reasons." Each one needed identification and rewrite. Plan for a full audit, not a global find-replace.

2. The B2B Suite trap

Adobe's B2B Suite isn't just a feature — it's an architectural dependency. Company accounts, shared catalogs, quote workflows, requisition lists, and tiered pricing for company structures all live in this module.

If you use it, your options are:

Rebuild from scratch (8-12 weeks of senior dev time)
Replace with paid alternatives (Aitoc, Wyomind, Magexperts have partial coverage)
Drop the functionality (sometimes acceptable, often not)

There is no migration path. The data export is partial. The schema doesn't map cleanly. We've seen this kill migration projects in week 2.

If you depend on B2B Suite, get a specific rebuild estimate BEFORE committing to migration.

3. Adobe Sensei recommendation widgets

This one's quieter and easier to miss. Sensei (Adobe's AI recommendation engine) leaves orphaned database tables and broken admin pages after migration if you don't clean them up explicitly.

Replacement options for product recommendations:

Self-hosted ML
Open source modules (mgt-commerce/related-products, amasty/recommendations)
Rebuild on top of Magento's native related products engine

None are drop-in. Budget 2-4 weeks for whatever you choose.

4. Page Builder content drift

Page Builder content stored in CMS pages mostly survives migration — Open Source has Page Builder too. But Commerce-Cloud-only widgets (dynamic blocks tied to customer segments, staged content) render as empty divs.

Audit every CMS page before go-live. Replace dynamic blocks with static content or third-party segmentation modules.

5. Hosting migration is bigger than it sounds

This is the one teams underestimate most.

Adobe Cloud abstracts away Fastly, Platform.sh, cron jobs, deploy hooks, secrets management — you don't notice them because they "just work." When you move to Hypernode or similar:

Fastly VCL → rebuild or migrate to Varnish
.magento.app.yaml → your CI/CD pipeline
Adobe Cloud variables → environment management (we use Vault)
Cron jobs → manual provisioning
Deploy hooks → custom GitHub Actions / GitLab CI

Plan ~2 weeks of DevOps work. Not optional.

The cost math — honest version

Mid-market store, $2-3M GMV, 5-year comparison.

Adobe Commerce Cloud:

Item	Cost
Licence ($30k/yr × 5)	$150,000
Hosting	included
Adobe support	included
Total	$150,000

Magento Open Source (post-migration):

Item	Cost
Licence	$0
Hosting ($8k/yr × 5)	$40,000
Dev partner / in-house ($20k/yr × 5)	$100,000
One-time migration	$40,000-80,000
Total	$180,000-220,000

The 5-year savings ARE real — but they're mostly real for merchants who already have an in-house Magento dev OR a long-term dev partner relationship. If you'd need to hire a partner from scratch just to run Open Source, the math gets thinner.

Where the savings genuinely show up:

Year 6 onward (migration is amortised, licence still $0)
When Adobe raises the licence at renewal (commonly 15-20% increases)
When you'd otherwise need infrastructure Adobe Cloud doesn't allow (custom Redis, specific regions, headless storefronts with edge compute)

Decision framework

Migrate if you can say yes to most of these:

Licence cost ≥ $25k/year
You use ≤30% of Adobe-only features (no B2B Suite, light Sensei usage, no staging dependency)
Team has senior Magento experience (or trusted partner)
You want infrastructure flexibility Adobe doesn't allow
You're already planning major dev work (replatform, redesign, headless)

Stay on Adobe if:

Heavy B2B Suite usage
Compliance requirements where Adobe SLA matters
No DevOps capacity for self-managed infrastructure
Licence is bundled with other Adobe products you actively use

The one migration we didn't recommend

Of the three I mentioned at the top, the one we didn't migrate was a B2B distributor with deep Sensei + B2B Suite usage. Their license was $35k/yr — meaningful money — but rebuilding their B2B functionality would have cost ~$120k, and Sensei replacement another $40k. Payback was ~7 years before infrastructure savings, and they didn't have the DevOps capacity to manage it.

Sometimes the answer is "Adobe is expensive AND it's still the right choice." That's worth saying out loud.

What I'd ask before migrating

If you're considering this:

List every Adobe-only feature you use. Score each one 1-5 on "how critical"
Get a specific rebuild cost for everything you score 4-5
Add to that: migration cost, 2 weeks of DevOps, 6-12 months of dev partner ramp-up
Compare to 5-year licence cost INCLUDING expected annual increases
If self-managed math wins by less than 20%, stay. The risk premium isn't worth a marginal saving.

If you've migrated recently — what was the schema or dependency gotcha you didn't see coming? I'm collecting war stories for a deeper post on the technical pitfalls specifically.

Full cost breakdown and FAQ on the canonical: https://angeo.dev/migrating-from-adobe-commerce-cloud-to-magento-open-source-is-it-worth-it/

The Magento multi-store bug every AI description generator has — and how we fixed it

Ievgenii Gryshkun — Fri, 22 May 2026 05:02:09 +0000

A client came to us with 8,000 SKUs across four store views — English, Dutch, German, French. Descriptions were either copied from supplier PDFs or missing entirely. The fix was obviously AI generation. The less obvious problem was that every existing module we evaluated had the same architectural bug.

So we built our own, made it MIT-licensed, and put it on Packagist. This post is about the bug, the fix, and the four-provider abstraction (including a free one) we shipped on top.

🔗 Originally published on https://angeo.dev/magento-2-ai-product-description-generator/

The bug nobody talks about

Most Magento 2 AI content modules call this:

$product = $this->productRepository->get($sku, editMode: true);
$product->setCustomAttribute('description', $generated);
$this->productRepository->save($product);

Looks fine. It isn't. Without an explicit $storeId, this loads and saves in the default scope — Magento's global, store-view-independent fallback. When you save back, you overwrite every store view at once. The Dutch store gets English descriptions. The German store gets English descriptions. The French store gets English descriptions.

This is not a configuration problem. The multi-store architecture works correctly — the tooling ignores it. Writing to the default scope is simpler to implement than writing per store. Every commercial module we tested took the simpler path.

The right way:

// Load the product in the target store scope
$product = $this->productRepository->get($sku, false, $storeId);
$product->setCustomAttribute('description', $generated);

// Save with explicit store scope (Magento_Catalog\Model\Product\Action)
$this->productService->updateAttributes($sku, $generated, $storeId);

The difference is one parameter. The architectural cost is iterating stores around your generation loop. The data cost of skipping it is silently corrupting your multi-language catalog.

The framework around the fix

The store-scope fix is the boring part. The interesting part is everything you need around it.

┌─────────────────────────────────────────────────────┐
│       Angeo Multi-Store AI Content Framework        │
├──────────────┬──────────────────┬───────────────────┤
│  SKU Source  │ Store Iteration  │   AI Provider     │
│  ──────────  │  ──────────────  │  ──────────────── │
│  Catalog     │  Store 1 (EN)    │  OpenAI           │
│  G.Sheets    │  Store 2 (NL)    │  Claude           │
│  CLI --sku   │  Store 3 (DE)    │  Gemini           │
│              │  Store 4 (FR)    │  Groq (free)      │
├──────────────┴──────────────────┴───────────────────┤
│               Content Pipeline                      │
│  load(sku, storeId) → prompt → generate → save      │
├─────────────────────────────────────────────────────┤
│                    Output                           │
│  Magento DB · Local CSV · Google Sheets API v4      │
└─────────────────────────────────────────────────────┘

Four layers:

Provider Layer — uniform interface across OpenAI, Claude, Gemini, Groq
Store Iteration Layer — resolves all active store views before processing any SKUs
Content Pipeline — for each store × SKU: load in scope → build prompt → generate → save in scope
I/O Layer — reads SKUs from catalog, Google Sheet, or CLI; writes to Magento DB, CSV, and Google Sheets

The provider abstraction is the part most people will copy. One interface:

interface AiProviderInterface
{
    public function generate(string $system, string $user): string;
}

Wired in di.xml:

<type name="Angeo\AiDescriptionUpdater\Service\AiProviderService">
  <arguments>
    <argument name="providers" xsi:type="array">
      <item name="openai" xsi:type="object">...OpenAiProvider</item>
      <item name="claude" xsi:type="object">...ClaudeProvider</item>
      <item name="gemini" xsi:type="object">...GeminiProvider</item>
      <item name="groq"   xsi:type="object">...GroqProvider</item>
    </argument>
  </arguments>
</type>

Adding a fifth provider is one class + one line. The pipeline, store iteration, and I/O don't change. This is the pattern, not just the code.

The four-provider benchmark

200 product descriptions from a real Dutch jewellery store, same system prompt, same product names, all four providers.

Speed (avg per description)

Provider	Model	Avg. time
Groq	llama-3.3-70b-versatile	0.8s
Groq	mixtral-8x7b-32768	0.6s
Google	gemini-2.0-flash	1.2s
Anthropic	claude-haiku-4-5	1.1s
OpenAI	gpt-4.1-mini	1.4s
OpenAI	gpt-4.1	2.1s
Anthropic	claude-sonnet-4-6	2.8s

For 32,000 generations (8,000 SKUs × 4 store views): Groq ≈ 7 hours, GPT-4.1 ≈ 19 hours.

Cost (per 1,000 descriptions, ~200 words each)

Provider	Model	Cost / 1k
Groq	llama-3.3-70b-versatile	$0.00 (free tier)
Google	gemini-2.0-flash	~$0.08
OpenAI	gpt-4.1-mini	~$0.24
Anthropic	claude-haiku-4-5	~$0.32
OpenAI	gpt-4.1	~$1.80
Anthropic	claude-sonnet-4-6	~$2.40

Quality (manual review of 200 samples)

Criteria	Groq Llama 3.3	GPT-4.1-mini	GPT-4.1	Claude Sonnet
Factual accuracy	★★★★☆	★★★★☆	★★★★★	★★★★★
Language fluency	★★★★☆	★★★★☆	★★★★★	★★★★★
SEO keyword use	★★★☆☆	★★★★☆	★★★★☆	★★★★☆
HTML formatting	★★★★☆	★★★★☆	★★★★★	★★★★★

Practical recommendation: Validate prompts with Groq first — it's free, fast, and good enough to test workflow. Production on GPT-4.1-mini if SEO keyword density matters. Flagship products on GPT-4.1 or Claude Sonnet if copy quality directly affects conversion.

Why Groq matters

Groq's free tier is 14,400 requests/day. No credit card. Llama 3.3 70B output quality is genuinely good — ~1 star behind GPT-4.1 in our review, mostly on SEO keyword density.

For 8,000 SKUs × 4 stores = 32,000 calls, you're at ~1.85 days on the free tier. For most stores under 5,000 SKUs, this is free production-grade AI content generation if you're patient.

No other Magento module supports Groq at time of writing. This was the killer feature for our client.

Installation

composer require angeo/module-ai-description-updater
bin/magento setup:upgrade
bin/magento setup:di:compile
bin/magento cache:flush

First run (Groq, ~5 minutes from zero):

# 1. Get a free API key at console.groq.com
# 2. In admin: Stores → Configuration → Angeo → AI Description Updater
#    AI Provider = Groq (Free), paste key, Dry Run = Yes
# 3. Test on one SKU
bin/magento angeo:ai-description:run --sku=MY-SKU-001 --dry-run

# 4. If output looks good, disable dry-run and run the batch
bin/magento angeo:ai-description:run

Other useful flags:

bin/magento angeo:ai-description:run --sku=ABC-123     # single SKU, all stores
bin/magento angeo:ai-description:run --store=2         # single store view
bin/magento angeo:ai-description:run --dry-run         # generate, don't save

CLI-first by design. The 8,000-SKU client doesn't want a UI; they want cron.

Why it's open source

The honest answer: distribution. We sell AEO audits and full-stack Magento services. The modules are how stores find us. The code is free; the expertise applied to a specific store is not.

It's a familiar model — Vercel does it with Next.js, Sentry does it with sentry-php. The artefact is open; the operator is the product.

Key takeaways for Magento devs

Default-scope writes are silent multi-store corruption. Audit any AI/content module before installing on a multi-store catalog. Look for $storeId parameters in productRepository->get() and save calls.
Provider abstraction is one interface plus a di.xml array. Don't hardcode OpenAI. Future you (or future LLM pricing) will thank you.
Groq is the current sweet spot for free Magento AI generation. Llama 3.3 70B output is production-acceptable for most stores; the 14,400/day cap is workable for catalogs under ~5,000 SKUs.
GPT-4.1-mini is the best paid-tier value. Comparable to GPT-4.1 at ~17% of the cost.
CLI + cron beats admin UI for catalogs above ~500 SKUs. Click-by-click generation isn't a workflow.

The Magento product description that AI can't read

Ievgenii Gryshkun — Fri, 15 May 2026 07:03:48 +0000

This article was originally published on angeo.dev.

You installed robots.txt rules for GPTBot and OAI-SearchBot. You generated llms.txt. You added Product schema. The AEO audit is mostly green.

And ChatGPT still recommends your competitor.

There is a good chance the problem is not in any of those signals. It is in your product page itself — specifically in how Magento renders product content relative to what AI extraction systems actually process.

How your product page travels through an AI recommendation system

Magento HTML response
         ↓
AI crawler fetches raw HTML
(limited or no JavaScript rendering)
         ↓
Extraction layer parses text, headings, structured data
         ↓
Content chunking — splits page into retrievable units
         ↓
Relevance scoring — ranks chunks against query intent
         ↓
LLM answer synthesis — selects candidates for the response
         ↓
Citation / recommendation

The extraction layer is where most Magento stores lose. If your product description is collapsed behind a tab, or rendered only after JS executes — your product may never become a strong candidate for prompts like:

"best trail running shoes under €150"
"comfortable sneakers for all-day walking"
"running shoes with visible air cushioning"

This is not an indexing problem. It is a retrieval problem.

Content visibility is not binary

For AI extraction systems, content falls into at least four levels:

Level	How the content exists	Extraction reliability
1	Server-rendered, early in HTML	High
2	Server-rendered but hidden or collapsed	Reduced — parser-dependent
3	Present in DOM only after JS execution	Low
4	Loaded async after user interaction	Very low

Googlebot runs a full headless Chrome pipeline — levels 2–4 are "indexable enough" for SEO. Most AI crawlers do not. Even where partial rendering exists, JS-dependent content is significantly less reliable for AI extraction than server-rendered HTML.

What actually happens on a default Magento product page

Magento 2's standard layout wraps descriptions inside a tabs widget (data-mage-init='{"tabs": {...}}'). In most Luma configs:

The description is in the server-rendered HTML — but marked inactive, collapsed, and positioned deep in the document
It appears after hundreds of characters of navigation markup, widget JSON, form keys, and boilerplate

Run this to see what AI actually sees:

curl -s "https://yourstore.com/your-product-url.html" \
  | python3 -c "
import sys, re
html = sys.stdin.read()
text = re.sub(r'<[^>]+>', ' ', html)
text = re.sub(r'\s+', ' ', text).strip()
print(text[:3000])
"

What you want: product description text appearing clearly in the first 3000 characters.

What commonly appears: product name, price, SKU, breadcrumb, button text, widget boilerplate — and very little substantive content.

Three approaches to fix it

Approach 1 — Make the description tab active by default

Lowest effort. Sets the description tab as active on load so the content is not hidden at the CSS level.

<!-- app/design/frontend/YourVendor/YourTheme/Magento_Catalog/layout/catalog_product_view.xml -->
<referenceBlock name="product.info.details">
    <arguments>
        <argument name="config" xsi:type="array">
            <item name="settings" xsi:type="array">
                <item name="active" xsi:type="boolean">true</item>
            </item>
        </argument>
    </arguments>
</referenceBlock>

Keeps tab UI intact for visitors. Moves content from Level 2 collapsed → Level 2 visible.

Approach 2 — Render description directly above tabs

Moves description to Level 1 — early in the HTML, clearly associated with the product, before any tabs infrastructure.

<!-- catalog_product_view.xml override in your theme -->
<referenceContainer name="product.info.main">
    <block class="Magento\Catalog\Block\Product\View\Description"
           name="product.description.above.tabs"
           template="YourVendor_Theme::product/description-visible.phtml"
           after="product.info.price"/>
</referenceContainer>

<?php
// view/frontend/templates/product/description-visible.phtml
$description = $block->getProduct()->getData('description');
if (!$description) return;
?>
<section class="product-description-aeo" itemprop="description">
    <?= /* @noEscape */ $description ?>
</section>

Keep the tabs further down for human navigation — description appears in both places, but the extraction-friendly version is unconditional.

Approach 3 — Render all tab content into the initial HTML

The most comprehensive fix. All tab content is in the initial HTML response; tabs widget hides non-active tabs via CSS only.

<!-- Override of Magento_Catalog::product/view/details.phtml -->
<div class="product-tabs" data-mage-init='{"tabs":{"active":0}}'>
    <?php foreach ($block->getGroupChildNames('detailed_info') as $alias): ?>
    <?php $childBlock = $block->getLayout()->getBlock($alias); ?>
    <?php if (!$childBlock) continue; ?>

    <div class="data item title">
        <a data-toggle="trigger" href="#tab-<?= $block->escapeHtmlAttr($alias) ?>">
            <?= $block->escapeHtml($childBlock->getTitle()) ?>
        </a>
    </div>

    <div class="data item content"
         id="tab-<?= $block->escapeHtmlAttr($alias) ?>"
         data-role="content">
        <?= $childBlock->toHtml() ?>
    </div>
    <?php endforeach; ?>
</div>

AI parsers reading raw HTML see everything. Visitors see only the active tab.

Hyva Theme

Hyva uses Alpine.js x-show directives. Description is typically in the HTML — but structural noise around it reduces extraction clarity.

Most reliable fix: render the description once outside the Alpine component, as clean server-side HTML, early in the product layout.

<!-- In your Hyva theme's catalog_product_view.xml -->
<referenceContainer name="product.info.main">
    <block class="Magento\Catalog\Block\Product\View\Description"
           name="product.description.retrieval"
           template="YourVendor_Theme::product/description-server.phtml"
           after="product.info.price"/>
</referenceContainer>

Server-side JSON-LD — same rule applies

If your JSON-LD is injected via GTM or hydrated client-side, AI extraction systems often don't see it.

Schema delivery	Availability to AI parsers
Server-rendered in `<head>`	Reliable
Inline in `<body>` before tabs	Reliable
Injected by GTM after page load	Often unavailable
Hydrated by JS framework on mount	Often unavailable
Deferred script with `async`/`defer`	Inconsistent

Verify:

curl -s "https://yourstore.com/your-product.html" \
  | grep -o '"@type": "Product"'

No output = schema is client-side rendered.

What the difference looks like

Before — default Magento, description at Level 2, deep in document:

[~900 chars: navigation, breadcrumbs, price markup, button attributes,
 data-mage-init JSON, widget config, form keys, UI boilerplate]

 "description": "The Nike Air Max 90 features visible Air cushioning..."

[content buried, collapsed, structurally ambiguous]

After — description at Level 1, early in document:

[~120 chars: minimal structural markup]

The Nike Air Max 90 is built for all-day comfort with visible Air
cushioning in the heel. Upper: leather and synthetic mesh. Weight: 310g.
Outsole: rubber, minimum 20% recycled content. Sizes: EU 38–47.

Key features:
- Visible Air unit in heel
- Foam midsole
- Waffle-pattern rubber outsole

The second version is what an extraction system reads when deciding if your product is a strong candidate for "best running shoes with visible air cushioning."

Summary

Most AEO guides focus on what to add — llms.txt, schema, AI bot permissions. This problem is about how content is exposed: its position in the document, whether it is server-rendered, and whether AI extraction can reach it without JavaScript.

The fix in most cases takes under an hour. Layout XML overrides, no new modules, no API keys.

Run the curl test on your top-selling product now. If the description text is not readable in the first few thousand characters of the source — you know where the gap is.

The angeo/module-aeo-audit checks rendering visibility alongside robots.txt, llms.txt, schema, and six other AEO signals in one CLI command.

Full article with schema delivery comparison table and Hyva deep-dive: angeo.dev →

Magento 2 Product JSON-LD Schema for AI Search — Complete Guide (2026)

Ievgenii Gryshkun — Tue, 05 May 2026 12:11:41 +0000

Even if your Magento store ranks well in Google, it may still not appear in AI-generated product results (ChatGPT, Gemini, Perplexity).

A common reason is missing or incomplete Product schema.

AI systems rely on structured data to extract pricing and availability. When that data is missing or inconsistent, products may not be eligible for inclusion. This guide covers what is typically missing, why, and how to fix it.

TL;DR:

Magento 2 outputs microdata by default; JSON-LD is generally more reliable and easier for parsers to consume

Missing offers.availability is a common issue that breaks product eligibility for AI-powered shopping results

Schema injected via GTM is often not visible to non-JavaScript crawlers

Hyvä Theme does not include product schema out of the box

What is AI Search?

By "AI search" we refer to systems like ChatGPT browsing (via OAI-SearchBot), Google AI Overviews, Gemini, and Perplexity that extract structured data from pages to generate answers and product listings.

Unlike traditional search engines that primarily rank links, these systems rely more heavily on structured data like JSON-LD to understand product details — price, availability, ratings — rather than inferring them from HTML layout.

Before vs After: Schema and AI Eligibility

Setup	ChatGPT Shopping	Gemini	Perplexity
No schema	❌ Not eligible / rarely shown	❌ Not eligible	❌ Rarely cited
Microdata only (Luma default)	⚠️ Partially parsed	⚠️ Inconsistent	⚠️ Inconsistent
JSON-LD, missing `offers.availability`	⚠️ Often fails eligibility check	⚠️ May appear	⚠️ May appear
Full JSON-LD + availability + rating	✅ Eligible for Shopping results	✅ Product results	✅ Cited with price

Why Magento 2 Falls Short for AI Schema

Default Luma theme outputs microdata — the older itemscope/itemprop HTML format:

<!-- Default Magento Luma — often insufficient for AI search -->
<div itemscope itemtype="http://schema.org/Product">
  <span itemprop="name">Product Name</span>
  <div itemprop="offers" itemscope itemtype="http://schema.org/Offer">
    <span itemprop="price">49.99</span>
    <!-- offers.availability not present -->
  </div>
</div>

Three issues worth addressing for AI search:

1. Microdata vs JSON-LD. JSON-LD is generally more reliable because it is self-contained and easier to parse compared to microdata embedded in HTML. Microdata is also more fragile when themes or extensions modify markup.

2. offers.availability is missing. This field tells AI systems whether a product can actually be purchased. Without a valid value, products may not pass eligibility checks for AI-powered shopping results.

3. JavaScript-rendered schema may not be indexed. While Google Search processes JS-rendered content reasonably well, many AI crawlers rely on the initial HTML response. Schema injected after page load (e.g. via GTM) is often not visible to these crawlers.

On GTM specifically: While Google Search may process JavaScript-rendered schema, many AI crawlers rely on the initial HTML response. If all your structured data comes from GTM, there's a good chance AI systems aren't seeing it — even if Google Rich Results Test passes.

Real Example

A Magento store with correct pricing but missing offers.availability:

Passed Google Rich Results Test ✅
Had valid microdata with price and name ✅
Did not appear consistently in AI-generated product listings ❌

After adding JSON-LD with "availability": "https://schema.org/InStock" and validating via curl (server-side output), the product became eligible for AI Shopping results.

This is the most common schema issue across Magento stores — and it takes about five minutes to fix.

The Copy-Paste Product JSON-LD

A spec-compliant block that covers all the fields AI systems look for:

<script type="application/ld+json">
{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Alpine Hiking Jacket",
  "description": "Waterproof 3-layer shell for alpine conditions.",
  "sku": "WB-004",
  "image": ["https://yourstore.com/media/catalog/product/jacket.jpg"],
  "brand": { "@type": "Brand", "name": "TrailMaster" },
  "offers": {
    "@type": "Offer",
    "priceCurrency": "EUR",
    "price": "189.99",
    "priceValidUntil": "2026-12-31",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition",
    "url": "https://yourstore.com/alpine-hiking-jacket.html",
    "seller": { "@type": "Organization", "name": "Your Store Name" }
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "38",
    "bestRating": "5",
    "worstRating": "1"
  }
}
</script>

Required and Recommended Fields

Field	Status	Common mistake
`@type: Product`	✅ Required	—
`name`	✅ Required	HTML tags in name string
`offers.availability`	✅ Required	Text string instead of URI
`offers.price`	✅ Required	`"€189"` instead of `"189.99"`
`offers.priceCurrency`	✅ Required	Symbol `€` instead of code `EUR`
`image`	⚠️ Recommended	Relative URL instead of absolute
`sku`	⚠️ Recommended	Often missing entirely
`aggregateRating`	⚠️ Recommended	Including when `reviewCount` is 0 — causes validation error
`brand`	⚠️ Recommended	Plain string instead of `{"@type":"Brand","name":"..."}`

offers.availability — full URI required

Status	✅ Correct	❌ Often rejected
In stock	`https://schema.org/InStock`	`"In Stock"` / `"instock"`
Out of stock	`https://schema.org/OutOfStock`	`"Out of Stock"`
Pre-order	`https://schema.org/PreOrder`	`"preorder"`
Back order	`https://schema.org/BackOrder`	`"backorder"`

The full schema.org URI is what the spec requires. Short strings are technically invalid — parsers may accept them or silently ignore them depending on the implementation.

Configurable Products — Use AggregateOffer

When individual variants have different availability states, it's cleaner to use AggregateOffer so AI systems can understand the full option matrix:

{
  "@type": "Product",
  "name": "Running Shoe",
  "offers": {
    "@type": "AggregateOffer",
    "offerCount": 8,
    "lowPrice": "89.99",
    "priceCurrency": "EUR",
    "availability": "https://schema.org/InStock",
    "offers": [
      {
        "@type": "Offer",
        "sku": "RS-42-BLK",
        "name": "Size 42 / Black",
        "availability": "https://schema.org/InStock",
        "price": "89.99",
        "priceCurrency": "EUR"
      },
      {
        "@type": "Offer",
        "sku": "RS-43-BLK",
        "name": "Size 43 / Black",
        "availability": "https://schema.org/OutOfStock",
        "price": "89.99",
        "priceCurrency": "EUR"
      }
    ]
  }
}

Hyvä Theme — No Schema Out of the Box

Hyvä Theme is built on Alpine.js and does not include Luma's product templates. This means Hyvä Theme does not include product schema out of the box in its default templates — neither microdata nor JSON-LD.

Verify quickly:

curl -s https://yourstore.com/sample-product.html | grep -c 'application/ld+json'
# Returns 0 → no JSON-LD

curl -s https://yourstore.com/sample-product.html | grep -c 'itemscope'
# Returns 0 → no microdata either

The fix is to inject JSON-LD via layout XML so it's server-side rendered. Create Vendor_Theme/layout/catalog_product_view.xml:

<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:noNamespaceSchemaLocation="urn:magento:framework:View/Layout/etc/page_configuration.xsd">
    <head>
        <block class="Magento\Framework\View\Element\Template"
               name="product.json.ld"
               template="Vendor_Module::product/json-ld.phtml"/>
    </head>
</page>

Schema in <head> via layout XML is part of the initial HTML response — visible to crawlers that don't execute JavaScript.

Alternatively, you can use an open-source module like angeo/module-rich-data (MIT) to generate schema automatically for both Luma and Hyvä.

Diagnosing Your Current Schema

This one-liner checks what schema your product pages actually output:

curl -s https://yourstore.com/sample-product.html | \
  python3 -c "
import sys, json, re
body = sys.stdin.read()
blocks = re.findall(r'<script[^>]+type=\"application/ld\+json\"[^>]*>(.*?)</script>', body, re.DOTALL)
for b in blocks:
    try:
        d = json.loads(b)
        items = d if isinstance(d, list) else [d]
        for item in items:
            nodes = item.get('@graph', [item])
            for n in nodes:
                if n.get('@type') in ('Product', 'IndividualProduct'):
                    print('FOUND Product schema')
                    offers = n.get('offers', {})
                    if isinstance(offers, list): offers = offers[0] if offers else {}
                    print('availability:', offers.get('availability', 'MISSING'))
                    print('price:', offers.get('price', 'MISSING'))
                    print('aggregateRating:', 'present' if n.get('aggregateRating') else 'MISSING')
    except: pass
  "

Output	Meaning	Next step
No output	No JSON-LD schema	Add it or install a module
`availability: MISSING`	Offers block incomplete	Fix the offers object
`availability: InStock`	Text string (non-spec)	Change to full URI
`availability: https://schema.org/InStock`	✅ Correct	Validate at schema.org

Implementation Options

Option 1 — Module (5 min)

composer require angeo/module-rich-data
bin/magento setup:upgrade && bin/magento cache:flush

MIT licensed, works on Luma and Hyvä. Adds Product, Organization, BreadcrumbList, WebSite, FAQPage schema — all server-side rendered.

Option 2 — Manual phtml

Create Magento_Catalog/templates/product/json-ld.phtml:

<?php
$product = $block->getProduct();
$schema = [
    '@context' => 'https://schema.org/',
    '@type'    => 'Product',
    'name'     => $product->getName(),
    'sku'      => $product->getSku(),
    'offers'   => [
        '@type'         => 'Offer',
        'price'         => (string) $product->getFinalPrice(),
        'priceCurrency' => $block->getCurrencyCode(),
        'availability'  => $product->isAvailable()
            ? 'https://schema.org/InStock'
            : 'https://schema.org/OutOfStock',
        'itemCondition' => 'https://schema.org/NewCondition',
    ],
];
?>
<script type="application/ld+json">
<?= json_encode($schema, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES) ?>
</script>

Option 3 — GTM

Worth mentioning because it comes up a lot: GTM-injected schema works for Google Search, which processes JavaScript. For AI crawlers that rely on the initial HTML response, GTM schema may not be seen. If you're specifically targeting AI search visibility, server-side rendering is safer.

Validation Checklist

[ ] JSON-LD format (not microdata)
[ ] offers.availability — full schema.org URI
[ ] offers.price — number string, no currency symbol
[ ] offers.priceCurrency — ISO 4217 code (EUR, USD, GBP)
[ ] image — at least one absolute URL
[ ] aggregateRating omitted if reviewCount is 0
[ ] Schema present in raw curl output (server-side rendered)
[ ] Hyvä: schema injected via layout XML <head>
[ ] Configurable products use AggregateOffer with per-variant Offer
[ ] Zero errors at validator.schema.org

Common Errors

"The value of offers.availability is not valid"
Using a text string. Change to "https://schema.org/InStock".

"Missing field: offers.priceCurrency"
Add "priceCurrency": "EUR" to the offers object.

"ratingValue out of range"
Value must be between 1 and bestRating. A value of 0 is invalid — omit aggregateRating entirely if no reviews yet.

Full AEO Check

Product schema is one of 13 signals that affect AI search visibility in Magento. To check all of them at once:

composer require angeo/module-aeo-audit
bin/magento setup:upgrade && bin/magento cache:flush
bin/magento angeo:aeo:audit

Free CLI tool — weighted score across 13 signals, exact fix command for each failure.

If you're debugging Magento schema issues, the CLI audit tool above can save a lot of manual checking.

Originally published at angeo.dev

Magento 2 AEO Guide: Make Your Store Visible in ChatGPT, Gemini and Perplexity (2026)

Ievgenii Gryshkun — Wed, 29 Apr 2026 20:51:10 +0000

TL;DR — 2-minute version

Default Magento 2 stores are largely invisible to AI assistants (~25% AEO score)
The biggest blockers: robots.txt blocks AI bots, no llms.txt, Product schema missing offers.availability
You can audit your store in seconds: bin/magento angeo:aeo:audit
Most stores reach 80%+ AEO in ~90 minutes with basic fixes
ChatGPT Shopping requires a separate merchant registration at chatgpt.com/merchants

You've optimized your Magento store for Google. But when a shopper asks ChatGPT "what's a good cast iron pan under $80?" — your store isn't in the answer.

That's not an SEO problem. It's an AEO problem. And the fixes are completely different.

AI assistants are becoming a product discovery layer — not just a search tool. When a user asks for a recommendation, they've already formed intent. If your store isn't accessible to these systems, you're invisible at exactly that moment. That's a different problem from ranking fifth in Google — it's not being in the conversation at all.

This guide covers all 9 AEO signals for Magento 2, what each one means, and how to fix every gap — with exact CLI commands. The tooling referenced is open-source and on Packagist, but the signal framework applies to any Magento implementation.

Key terms

AEO — AI Engine Optimization
The practice of configuring a website so AI assistants — ChatGPT, Gemini, Perplexity — can discover, read, and recommend it. Different from SEO: targets AI-generated answers, not Google Search rankings. Relevant signals: robots.txt access, structured data, llms.txt, ACP product feeds.

Q: Is AEO the same as GEO (Generative Engine Optimization)?
Largely yes — both terms describe optimization for AI-generated results. AEO is used primarily in the eCommerce context; GEO is more common in content publishing. The underlying signals are the same.

OAI-SearchBot
OpenAI's live search crawler. Used when ChatGPT answers real-time queries. Respects robots.txt. Must be explicitly allowed — default Magento robots.txt blocks it via wildcard.

Q: Is OAI-SearchBot the same as GPTBot?
No. OAI-SearchBot is for live query answering. GPTBot is for training data collection. Blocking GPTBot has no effect on ChatGPT Shopping visibility.

ACP — Agentic Commerce Protocol
OpenAI's open standard for structured merchant product data. Defines a .jsonl.gz feed format submitted at chatgpt.com/merchants — required for ChatGPT product results.

llms.txt
A plain-text file at yourstore.com/llms.txt — a structured map of your catalog for AI systems. Spec at llmstxt.org. Similar to sitemap.xml, but optimized for AI consumption.

offers.availability
A required field in Product JSON-LD schema. Tells AI systems whether a product is in stock. Value: https://schema.org/InStock or https://schema.org/OutOfStock. Missing on most default Magento installations — its absence fails ChatGPT Shopping conformance checks.

AEO vs SEO: what's different

SEO gets your store ranked in Google's link list. AEO gets your store cited in AI-generated answers.

Google reads keywords, backlinks, and page authority. AI systems read:

robots.txt — can AI crawlers access your store at all?
llms.txt — is there a structured map of your catalog?
Product JSON-LD schema — can AI read prices, availability, and product details?
ACP product feed — have you registered with OpenAI's merchant program?

Most of these don't exist on a default Magento 2 install — not because Magento is broken, but because it was built before AI search existed.

Q: Does a store with good SEO automatically have good AEO?
No. Most signals don't overlap. A store can rank on page one of Google and still score near zero on AI product feed and llms.txt — because those signals didn't exist when the store was built.

Signal	Helps SEO	Helps AEO
robots.txt AI bot access	—	✅
llms.txt / llms.jsonl	—	✅
Product JSON-LD schema	✅	✅
FAQPage schema	✅	✅
ACP product feed	—	✅
sitemap.xml	✅	✅
Open Graph tags	✅	✅
Canonical tags	✅	✅

The 9 AEO signals for Magento 2

Run the free audit to see your current score:

composer require angeo/module-aeo-audit
bin/magento setup:upgrade
bin/magento angeo:aeo:audit

About the weights below: each signal has a weight (0.5–1.0) reflecting its relative impact on overall AEO score. Critical signals (robots.txt, schema, feed) are weight 1.0; supporting signals are lower. Failing a 1.0-weighted signal alone can drop you below the 50% threshold.

Signal #1 — robots.txt: AI Bot Access (weight 1.0)

The most common reason for complete AI invisibility. Magento's default robots.txt uses a wildcard rule (User-agent: *) combined with restrictive Disallow directives. Since AI crawlers like OAI-SearchBot, GPTBot, and PerplexityBot aren't explicitly listed, they inherit those restrictions and get blocked unintentionally.

Per OpenAI's crawler documentation, stores that block OAI-SearchBot may significantly limit or prevent visibility in ChatGPT search results.

This is the most frequently failing signal across all store sizes — and the cheapest to fix.

Check your file at yourstore.com/robots.txt. You need these entries, placed before any wildcard block:

User-agent: OAI-SearchBot
Allow: /

User-agent: GPTBot
Allow: /

User-agent: PerplexityBot
Allow: /

User-agent: Google-Extended
Allow: /

User-agent: ClaudeBot
Allow: /

Quick fix — two options:

Option A: edit robots.txt manually in your Magento admin (Stores → Configuration → Design → Search Engine Robots) or directly in the file. Make sure your edits actually persist (see the nginx warning below).

Option B: install a module that injects and validates the rules:

composer require angeo/module-robots-txt-aeo
bin/magento setup:upgrade && bin/magento cache:flush
bin/magento angeo:robots:validate

⚠️ Adobe Commerce Cloud: robots.txt is served via Fastly VCL. After any change — purge Fastly cache and verify the live file, not the admin config.

Signal #2 — llms.txt: AI Content Map (weight 1.0)

llms.txt is a plain-text file at yourstore.com/llms.txt — a structured map of your catalog: categories, key products, CMS pages, currency, language. Defined at llmstxt.org.

Perplexity's background indexer actively reads it. For ChatGPT Shopping, it supplements the ACP product feed.

You can hand-write llms.txt for a small catalog (the format is just markdown), but for stores with hundreds+ of products it gets stale fast. A common automation approach:

composer require angeo/module-llms-txt
bin/magento setup:upgrade
bin/magento angeo:llms:generate

This also generates llms.jsonl — the machine-readable sibling. Enable cron for automatic regeneration when your catalog changes.

→ Deep dive: How to generate llms.txt for Magento 2 in 5 minutes

Signal #3 — Product JSON-LD Schema (weight 1.0)

Magento's default Luma theme outputs basic Product schema but almost always omits offers.availability — a key field for ChatGPT Shopping conformance. Submissions without it commonly fail validation.

Q: Does Hyvä theme fix the schema problem automatically?
Partially. Hyvä has better schema defaults than Luma but still requires explicit configuration for offers.availability and variant-level data. Neither platform handles this out of the box — a dedicated module or theme override is required.

Quick check on any product page:

curl -s https://yourstore.com/sample-product | grep -o '"availability":"[^"]*"'

You can fix this either via a custom theme override or with a module. Example using a module:

composer require angeo/module-rich-data
bin/magento setup:upgrade && bin/magento cache:flush

This adds: offers.availability (real-time stock), aggregateRating, BreadcrumbList. It also covers Signal #5 — FAQPage schema on CMS pages.

The 4 most common schema failures I see (in order of frequency):

Missing offers.availability — 90%+ of default Magento stores. Without it, ChatGPT Shopping conformance fails outright.
Variant-level data flattened — configurable products lose variesBy data when serialized. ChatGPT shows "out of stock" even when 6 of 8 variants are available.
Hyvä strips microdata — performance optimization removes JSON-LD entirely. Needs a layout XML override to re-inject.
Wrong availability values — using "InStock" (string) instead of "https://schema.org/InStock" (URI). Validators accept it, AI engines silently drop it.

If your audit shows Signal #3 failing, run this diagnostic:

# Replace with any product URL from your store
curl -s https://yourstore.com/sample-product | \
  grep -A 20 'application/ld+json' | \
  grep -E 'availability|priceCurrency|sku'

If availability is missing or doesn't start with https://schema.org/, that's your problem.

Example — Magento 2 store, home goods, ~2,400 SKUs

⚠️ Before — default install:

AEO score: 23%
✗ robots.txt — OAI-SearchBot blocked
✗ llms.txt — not found
✗ Product schema — no availability
✗ AI product feed — not registered

✅ After — 90 minutes later:

AEO score: 84%
✓ robots.txt — 7 AI bots allowed
✓ llms.txt — 2,400 products mapped
✓ Product schema — availability live
◷ Feed — submitted, pending approval

💡 At this point — after signals #1, #2, and #3 — most stores jump from low-twenties into the 50–60% range. Run the audit again to confirm your progress before continuing:
bin/magento angeo:aeo:audit

Signal #4 — AI Product Feed / ChatGPT Shopping (weight 1.0)

ChatGPT Shopping requires a registered ACP product feed. Without it, products are unlikely to appear in ChatGPT Shopping results regardless of other signals. The feed is .jsonl.gz, submitted to a private SFTP endpoint provided by OpenAI after approval, refreshed every 15 minutes.

Building an ACP feed from scratch is doable but non-trivial — you need to handle JSONL streaming, gzip compression, SFTP auth, the offers.availability mapping, and 15-minute refresh cron. Most teams either build it in-house or use a module:

composer require angeo/module-openai-product-feed \
  angeo/module-openai-product-feed-api
bin/magento setup:upgrade
bin/magento angeo:aeo:feed:generate
bin/magento angeo:aeo:feed:validate

Apply at chatgpt.com/merchants. Currently US-only and waitlisted. After approval, set up 15-minute cron — stale availability data is the #1 reason for post-approval suppression.

→ Deep dive: How to Register Your Magento 2 Store for ChatGPT Shopping

Does this actually move the needle?

Fair question — and the honest answer is "yes, but unevenly across platforms."

Perplexity shows the fastest impact. Background re-indexing typically picks up llms.txt and schema changes within days to a few weeks.
ChatGPT is gated by merchant approval. Technical fixes alone won't get you into Shopping results — you also need the feed registered and approved. Once approved, indexing is usually 48–72 hours.
Gemini mostly piggybacks on Google Merchant Center. If you're already there, fixes propagate quickly. If not, getting into Merchant Center is the bigger lift than AEO itself.

AEO is not instant. But with these signals failing, visibility across all three engines is close to zero — fixing them is the floor, not the ceiling.

Signals #5–#9 — Supporting Signals

FAQPage schema (weight 0.5)
Increases citation probability for answer-style AI queries. Injected automatically alongside Product schema on CMS pages. Verify:

curl -s yourstore.com | grep FAQPage

sitemap.xml (weight 0.8)
AI crawlers use sitemap.xml to discover your full catalog. Enable in Magento admin: Stores → Config → Catalog → XML Sitemap. Submit to Google Search Console — also surfaces to Google-Extended (Gemini).

Open Graph tags (weight 0.7)
og:title, og:description, og:image — used as content fallback when structured schema is absent. Most Magento themes include these by default.

Canonical tags (weight 0.6)
Prevents AI systems from indexing Magento's multiple URL variants. Enable: Stores → Config → Catalog → SEO → Use Canonical Link Meta Tag For Products/Categories.

Note: Magento has no canonical option for the homepage — this is expected.

llms.jsonl (weight 0.75)
Machine-readable catalog at yourstore.com/llms.jsonl. One JSON object per product per line. Used by AI pipelines for vector indexing. Generated automatically by angeo/module-llms-txt.

ChatGPT vs Perplexity vs Gemini: how each AI discovers products

ChatGPT — hybrid approach: trained knowledge + live search via OAI-SearchBot + ACP merchant product feed. Requires merchant registration. Feed is the authoritative source for product data.

Perplexity — real-time answer engine. Always cites sources with links. PerplexityBot actively reads llms.txt — one of the few AI platforms where this has documented crawl value. No separate product feed required.

Gemini — operates on Google's Shopping Graph (50B+ products, updated 2B+ times per hour). Any product in Google Merchant Center is available to Gemini. Google-Extended is the separate crawler for AI Overviews — allowing it does not affect regular Google Search rankings.

Cheat sheet — what each engine actually reads:

Source	ChatGPT	Perplexity	Gemini
ACP product feed	✅ primary	—	—
OAI-SearchBot crawl	✅ secondary	—	—
llms.txt	⚠️ untested	✅ documented	⚠️ untested
Product JSON-LD	✅	✅	✅ via Shopping Graph
Google Merchant Center	—	—	✅ primary
Open Graph tags	✅ fallback	✅ fallback	✅ fallback
robots.txt	`OAI-SearchBot`, `GPTBot`, `ChatGPT-User`	`PerplexityBot`	`Google-Extended`

The pattern: ChatGPT prefers structured submissions (the feed), Perplexity prefers crawl-discoverable structure (llms.txt + schema), Gemini piggybacks on Google's existing pipelines (Shopping Graph + Merchant Center). Cover all three and you're visible across the major engines.

Score interpretation

Score	Label	Typical situation
0–25%	Needs Improvement	Default Magento install. AI crawlers blocked.
26–50%	Needs Improvement	Some fixes applied. Schema or feed still missing.
51–75%	Moderate	Core signals in place. Feed not yet registered.
76–90%	Good	Strong foundation. Minor schema gaps.
91–100%	Excellent	Full compliance. Feed registered and live.

Free open-source modules — one per signal

Each AEO signal has a corresponding open-source Magento 2 module. MIT licensed. Install via Composer. Runs on your server — no external API calls, no data sent outside your infrastructure.

Module	Signal
`angeo/module-aeo-audit`	Diagnostic — checks all 9 signals, score trend dashboard
`angeo/module-robots-txt-aeo`	Signal #1 — injects AI bot rules into robots.txt
`angeo/module-llms-txt`	Signals #2, #2b — generates llms.txt and llms.jsonl
`angeo/module-rich-data`	Signals #3, #5 — Product JSON-LD + FAQPage schema
`angeo/module-openai-product-feed`	Signal #4 — ACP product feed for ChatGPT Shopping

90-minute implementation checklist

Baseline audit: bin/magento angeo:aeo:audit — note your starting score
Fix robots.txt: composer require angeo/module-robots-txt-aeo → validate with angeo:robots:validate
Generate llms.txt: composer require angeo/module-llms-txt → angeo:llms:generate
Fix Product schema: composer require angeo/module-rich-data → verify offers.availability in page source
Enable sitemap: Stores → Config → Catalog → XML Sitemap → Enable → submit to Search Console
Generate product feed: composer require angeo/module-openai-product-feed angeo/module-openai-product-feed-api
Apply for ChatGPT Shopping: configure seller name + policy URLs → apply at chatgpt.com/merchants
Final audit: bin/magento angeo:aeo:audit → target 80%+

Adobe Commerce Cloud: additional steps

Adobe Commerce Cloud adds one complication — Fastly CDN. robots.txt is stored in pub/media/ and served via a Fastly VCL snippet. After any robots.txt change:

Save in Magento admin
Purge Fastly cache
Verify the live file at yourstore.com/robots.txt — not the admin config

Fastly also caches product pages. If availability changes but Fastly serves a stale page, OAI-SearchBot reads incorrect stock data — leading to product suppression after ChatGPT Shopping approval. Use the 15-minute cron for the ACP product feed as the authoritative source for availability.

Adobe Commerce vs Magento Open Source — AEO-relevant differences:

Open Source: robots.txt is editable directly, cron is yours, no Fastly cache layer to invalidate. AEO setup is straightforward.
Adobe Commerce Cloud: Fastly is mandatory, robots.txt is served via VCL, cron has timing constraints. Every AEO change needs an extra "purge Fastly" step.
B2B Commerce on Adobe Commerce: customer-group pricing breaks ACP feed assumptions (the protocol expects single price per SKU). You'll need a separate "public" feed with B2C pricing for ChatGPT Shopping. Don't expose B2B pricing to AI engines.

If you're on Adobe Commerce Cloud, expect implementation to take 2-3x longer than vanilla Magento — most of the extra time is fighting Fastly cache TTLs, not AEO logic itself.

Frequently asked questions

Does AEO replace SEO for Magento stores?

No. They target different channels. SEO gets you ranked in Google Search. AEO gets you cited in AI-generated answers. A store with strong SEO can still score very low on AEO by default — because the signals are completely different.

Is ChatGPT Shopping free for merchants?

Product discovery is currently organic — no cost to appear in results. No transaction fees on purchases that start in ChatGPT as of April 2026. Onboarding is US-only and waitlisted.

How long before results are visible after fixing AEO?

Technical fixes take effect as AI crawlers re-index your pages: 1–3 weeks for Perplexity, 2–6 weeks for Google-Extended, 48–72 hours after ChatGPT Shopping approval for the feed layer.

What is GPTBot vs OAI-SearchBot?

GPTBot is OpenAI's training crawler. Blocking it opts your content out of GPT model training but has no effect on ChatGPT Shopping visibility. OAI-SearchBot is the live search crawler — this one must be allowed.

Does this work with Hyvä theme?

Yes. All Angeo modules are compatible with Magento Open Source and Adobe Commerce on both Luma and Hyvä themes. PHP 8.2+ required.

Start here

Run the audit:

bin/magento angeo:aeo:audit

If your score is below 50%, your store is likely invisible to AI assistants today. Fixing the first 3 signals (robots.txt, llms.txt, Product schema) usually gets you most of the way there.

Install CLI Audit — MIT-licensed, runs on your server, no telemetry
Free Web Self-Assessment — no install required, runs against your live site

llms.txt for Magento 2: What It Is, Why It Matters, and How to Generate It in 5 Minutes

Ievgenii Gryshkun — Fri, 24 Apr 2026 04:48:48 +0000

Google has robots.txt. Google has sitemap.xml. Now AI assistants have llms.txt.

If you run a Magento 2 store and haven't heard of llms.txt yet — this post is the 5-minute version of everything you need to know, plus the exact commands to generate it today.

The problem: AI assistants don't crawl like Google does

When Google indexes your store, its crawler visits thousands of pages and builds a picture of your catalog over weeks. It's slow, but it works.

ChatGPT, Claude, and Perplexity operate differently. When a user asks "what's a good blender under $150?", the AI doesn't crawl your store in real time. It works from what it already knows — or from a structured snapshot it can parse in milliseconds.

If you haven't given it that snapshot, it either ignores your store or gets the details wrong: outdated prices, discontinued products, categories that no longer exist.

llms.txt is that snapshot.

What is llms.txt?

llms.txt is a plain-text file hosted at the root of your domain — yourstore.com/llms.txt — that gives AI systems a structured, human-readable summary of your store.

Think of it as a README.md for your entire eCommerce site. It tells AI assistants:

What your store sells
What categories exist
Key product URLs and descriptions
CMS pages (shipping, returns, about)
Store metadata: name, currency, language

A minimal example looks like this:

# Store: Volta Equipment

## STORE
Name: Volta Equipment
URL: https://voltaequipment.com/
Currency: USD

### CATEGORIES ###
Category ID: 4
Name: Fitness Equipment
URL: https://voltaequipment.com/fitness
Description: Commercial and home gym equipment

### PRODUCTS ###
SKU: VE-KB32
Name: 32kg Kettlebell — Cast Iron
Price: 8900
URL: https://voltaequipment.com/32kg-kettlebell
Short Description: Competition-grade cast iron kettlebell, powder-coated finish

## CMS PAGES
TYPE: PAGE
TITLE: Shipping Policy
URL: https://voltaequipment.com/shipping

Simple. No JSON schema. No special syntax. Just structured plain text that both AI systems and humans can read instantly.

Does llms.txt actually work?

Fair question — and the honest answer is: it depends on the AI.

Some AI systems (Perplexity, some Claude configurations) actively read llms.txt when crawling. Others, like GPTBot, primarily rely on the page content itself and Product schema JSON-LD. OpenAI has not yet published an official spec for llms.txt consumption.

So why generate it at all?

Three reasons:

1. It costs nothing to add. One Composer command and it's live. There's no downside.

2. It's a trust signal. When a Magento developer or agency reviews your AEO setup, a present llms.txt signals you're thinking about AI visibility — and it's one of the 8 signals checked by the AEO audit module.

3. The standard is evolving fast. OpenAI, Anthropic, and Google are all moving toward structured merchant data formats. Stores with llms.txt already in place will require zero additional work when these systems formalize their specs. Stores without it will have to catch up.

llms.txt vs llms.jsonl — what's the difference?

The angeo/module-llms-txt module generates both files. Here's when each matters:

File	Format	Best for
`llms.txt`	Plain text	AI assistants reading store context, Perplexity, Claude
`llms.jsonl`	JSON Lines	Structured product data, future ACP integrations, developers

llms.jsonl is the machine-readable sibling — one JSON object per product, per line, compressed for fast parsing. If you're planning to integrate with OpenAI's ACP feed later, llms.jsonl is the stepping stone.

For now, generate both. They serve different consumers.

Installation: 3 commands

composer require angeo/module-llms-txt
bin/magento setup:upgrade
bin/magento cache:flush

That's it. The module is MIT licensed, free on Packagist, and runs entirely on your server.

Generate the files

Option A — CLI (recommended)

bin/magento angeo:llms:generate

This generates both llms.txt and llms.jsonl at your store root and outputs the file paths.

Option B — Magento Admin

Go to Stores → Configuration → General → Angeo → LLMS and trigger manual generation from the backend.

Option C — Cron (for automatic updates)

The module registers a Magento cron job. As long as your server cron is running, the files stay current:

bin/magento cron:run

For stores with frequently changing inventory — new products, price updates, seasonal categories — cron is the right default.

Verify it's live

After generation, open yourstore.com/llms.txt in a browser. You should see your store name, category list, and product entries.

Then run the AEO audit to confirm it passes signal #2:

bin/magento angeo:aeo:audit

Expected output:

✓ PASS  robots.txt — OAI-SearchBot and GPTBot allowed
✓ PASS  llms.txt — store content map present
...

If llms.txt shows FAIL, check that the file exists at pub/llms.txt and that your web server is serving it correctly (not blocked by nginx or a CDN rule).

Multi-store support

If you're running multiple store views or storefronts, the module generates separate llms.txt files per store — each with the correct currency, language, and URL structure. No additional configuration needed.

What to do after llms.txt

llms.txt is AEO signal #2. To complete your AI visibility setup, the remaining signals are:

✅ robots.txt — Allow OAI-SearchBot, GPTBot, ClaudeBot, and 4 others
✅ llms.txt — structured store map ← you are here
→ Product Schema — JSON-LD with offers.availability on every product page
→ AI Product Feed — ACP-compliant .jsonl.gz for ChatGPT Shopping registration
→ FAQPage Schema — structured Q&A for policy pages

Run bin/magento angeo:aeo:audit to see your current score across all 8 signals.

Summary

llms.txt gives AI assistants a structured snapshot of your store
It's served at yourstore.com/llms.txt — same pattern as robots.txt
The angeo/module-llms-txt module generates it automatically, with cron support
It takes 3 commands and under 5 minutes to set up
It's one of 8 AEO signals that determine your visibility in ChatGPT, Claude, and Perplexity

Free modules used in this post:

angeo/module-llms-txt — generates llms.txt and llms.jsonl
angeo/module-aeo-audit — checks all 8 AEO signals via CLI

Run a free AEO audit on your store →

How to Register Your Magento 2 Store for ChatGPT Shopping (ACP Feed + Step-by-Step)

Ievgenii Gryshkun — Mon, 20 Apr 2026 17:20:06 +0000

ChatGPT now processes over 50 million shopping queries per day. Appearing in those results is not automatic — it requires a deliberate application process, a spec-compliant product feed, and passing OpenAI's conformance checks.

This guide walks through the entire process: from the pre-check that determines if your store is ready, to the merchant application, to the ongoing cron setup that keeps your feed current.

Shopify and Etsy merchants already have native integrations. This guide is for Magento 2 / Adobe Commerce stores.

🔗 Originally published on angeo.dev

Before You Apply: The Pre-Check

OpenAI's conformance checks verify technical requirements before granting production access. Stores that fail the pre-check go into a review queue and receive vague rejection emails. Do the pre-check yourself first.

bin/magento angeo:aeo:audit

Expected output before you start:

✓ PASS  robots.txt — OAI-SearchBot and GPTBot allowed
✓ PASS  llms.txt — store content map present
✓ PASS  Product Schema — JSON-LD with offers.availability
✗ FAIL  AI Product Feed — no feed found

Signal #5 (AI Product Feed) will fail until Step 1 below. Signals #1, #2, and #3 must all PASS before applying at chatgpt.com/merchants.

If robots.txt is failing — most default Magento 2 installs have a User-agent: * wildcard that silently blocks OAI-SearchBot. Fix that first. It's a hard gate that invalidates everything else.

Step 1 — Install the product feed modules

composer require angeo/module-openai-product-feed \
  angeo/module-openai-product-feed-api

bin/magento setup:upgrade
bin/magento cache:flush

Both modules are MIT licensed, free on Packagist. No license keys, no SaaS — runs entirely on your server.

Step 2 — Configure seller information

Go to Stores → Configuration → Angeo → Product Feed API and fill in:

Seller name
Target country — ISO 3166 two-letter code (e.g. US)
Policy URLs — privacy policy, returns, shipping, terms of service

These populate seller.links on every product record. They are merchant credibility signals in OpenAI's scoring. Missing policy URLs is a common reason for suppressed products after initial approval.

Step 3 — Generate and validate the feed

# Generate the feed file
bin/magento angeo:aeo:feed:generate

# Validate structure and required fields
bin/magento angeo:aeo:feed:validate

Confirm in the output:

Each product has a variants array
Prices are in minor units (see the price format section below)
availability.status is present on every product
seller.links has at least two policy URLs

Step 4 — Verify promotions output

bin/magento angeo:aeo:feed:validate --type=promotions

Active Magento cart price rules should appear automatically as ACP promotions with active_period, benefits, and status: "active". If promotions are missing here, they won't appear in ChatGPT results either.

Step 5 — Apply at chatgpt.com/merchants

Submit your store URL and business details. OpenAI tests schema compliance, HTTP response codes, and feed integrity.

Current status: Onboarding is US-only and available to approved partners — expect a waitlist. Application review typically takes 1–2 weeks.

Step 6 — Receive SFTP endpoint and push the feed

After approval, OpenAI provides a private SFTP endpoint for your store. Push your .jsonl.gz feed file to this endpoint.

⚠️ Do not host the feed publicly on your website. The feed goes to the private SFTP endpoint OpenAI provides — not a public REST endpoint on your store. Submit a sample first; after it passes validation, push the full catalog.

Step 7 — Set up 15-minute cron

# crontab — every 15 minutes
*/15 * * * * /usr/bin/php /var/www/html/bin/magento angeo:aeo:feed:generate --push

OpenAI accepts feed refreshes every 15 minutes. Full feed re-submission is required each time — there is currently no incremental update support.

⚠️ Most common post-approval failure: Stale availability data — out-of-stock products showing as available — is the #1 reason products get suppressed after initial approval. The 15-minute cron prevents this.

Feed Format: What OpenAI Actually Accepts

Format	Extension	Notes
JSON Lines	`.jsonl.gz`	Recommended. One product object per line. Handles nested variants cleanly.
CSV	`.csv.gz`	Works for flat catalogs. Variant structures need to be flattened.

Note: TSV and XML were in OpenAI's original spec announcement but have since been removed. Always check the official feed spec for the current list.

The Price Format Trap

This is the single most common implementation error across all ACP integrations.

Price must be sent in ISO 4217 minor units as an integer:

# ❌ Wrong — fails validation
"price": 14.99
"price": "14.99"

# ✅ Correct — integer minor units
"price": 1499    // €14.99
"price": 14900   // $149.00

The module handles this automatically: (int) round($price * 100). But if you are building a custom integration or mapping from a Google Shopping feed — check this field first. The validation error message for a wrong price format is non-obvious.

What OpenAI's Conformance Check Validates

Check	What it verifies	Handled by
Feed schema	Required fields, correct data types, valid URIs	ProductMapper
Price format	Integer minor units, ISO 4217 currency code	ProductMapper
Availability flags	`enable_search` and `availability.status` present	ProductMapper
Promotion schema	`benefits` array with type, dates, `status: "active"`	PromotionMapper
Seller links	At least 2 policy URLs present	Admin config → seller.links
Product IDs	Unique, stable, no duplicates across the feed	ProductMapper

No Fees for Discovery

Product discovery results in ChatGPT are currently organic and unsponsored. There is no cost to submit a product feed or appear in shopping results.

The 4% transaction fee announced with Instant Checkout applied only to completed in-chat purchases — and OpenAI is moving away from that model toward merchant-owned checkout. As of April 2026, there are no fees on purchases that start in ChatGPT.

After approval, the feed needs to be indexed — typically 48–72 hours. Products with complete Product JSON-LD schema, high availability accuracy, rich descriptions, and active promotions appear first.

Checklist Before Submitting

[ ] bin/magento angeo:aeo:audit — robots.txt, llms.txt, Product schema all PASS
[ ] Feed generates without errors and produces valid .jsonl.gz
[ ] Each product has variants, correct prices in minor units, availability.status
[ ] Seller info complete: name, country (ISO 3166), at least 2 policy URLs
[ ] Active promotions appear with status: "active"
[ ] 15-minute cron configured and tested

All four Angeo modules are free, MIT licensed, and available on Packagist:

angeo/module-aeo-audit — AEO CLI audit, 8 signals
angeo/module-llms-txt — auto-generates llms.txt
angeo/module-openai-product-feed — ACP feed generator
angeo/module-openai-product-feed-api — REST API, 6 endpoints

Free AEO Self-Assessment →

How to Fix robots.txt for ChatGPT and Gemini in Magento 2 (2026 Update)

Ievgenii Gryshkun — Thu, 16 Apr 2026 20:41:06 +0000

Your sitemap is configured. Your Core Web Vitals score is green. Your product catalog is perfectly structured. And yet when a user asks ChatGPT for products you sell, your store doesn't appear.

Most of the time, the reason is a single file: robots.txt.

Specifically — a robots.txt written for Google in 2019 and never updated for the ten AI crawlers that now determine your visibility in ChatGPT, Gemini, Claude, and Perplexity.

🔗 Originally published at angeo.dev/magento-2-robots-txt-chatgpt-gemini-ai-bots

Why robots.txt Is AEO Signal #1

The angeo/module-aeo-audit checks robots.txt first and marks it Critical because it is a gate. Every other AEO signal — llms.txt, Product schema, AI product feed — is irrelevant if the AI crawler cannot enter your store.

OpenAI states this without ambiguity:

"Sites that are opted out of OAI-SearchBot will not be shown in ChatGPT search answers."

Not "may not appear." Will not appear. If OAI-SearchBot is blocked — by an explicit Disallow or caught in a wildcard rule — your store is excluded from ChatGPT search answers regardless of everything else.

The Three Types of AI Bots — Why the Difference Matters

Before listing every bot, understand what each one actually does. Conflating them causes the most common robots.txt misconfiguration.

Type	What it does	Examples	Recommendation
Search & indexing	Builds the live index used when users ask AI questions. Cites sources, links back to your store.	`OAI-SearchBot`, `Claude-SearchBot`, `PerplexityBot`, `Google-Extended`	✅ Always allow
User-initiated	Fetches your page when a user asks AI to visit a specific URL. May cite your product page directly.	`ChatGPT-User`, `Claude-User`, `Perplexity-User`	✅ Always allow
Training crawlers	Collects content for model training. No attribution, no traffic back.	`GPTBot`, `ClaudeBot`, `Applebot-Extended`	⚠️ Your choice

The most common mistake: blocking GPTBot (training) thinking it removes you from ChatGPT search results. It does not. GPTBot and OAI-SearchBot are entirely separate bots. Blocking training crawlers has zero effect on AI search visibility — but blocking search crawlers makes you invisible immediately.

Every AI Bot That Matters in 2026

Bot	Platform	Type	Impact if blocked
`OAI-SearchBot`	ChatGPT	Search index	Invisible in all ChatGPT search answers. Most critical.
`GPTBot`	ChatGPT	Training	Excluded from future GPT training. No effect on current search.
`ChatGPT-User`	ChatGPT	User-initiated	ChatGPT can't fetch your pages for users.
`Claude-SearchBot`	Claude	Search index	Invisible in Claude's real-time web search answers.
`ClaudeBot`	Claude	Training	Excluded from future Claude training data.
`Claude-User`	Claude	User-initiated	Claude can't fetch your pages for users.
`PerplexityBot`	Perplexity	Search index	Invisible in Perplexity answers and recommendations.
`Perplexity-User`	Perplexity	User-initiated	Perplexity can't fetch your pages for users.
`Google-Extended`	Gemini	Search + training	Not cited in Gemini AI Overviews or Google Shopping AI.
`Applebot-Extended`	Apple Intelligence	Training	Excluded from Apple Intelligence training data.
`anthropic-ai`	Anthropic	Deprecated	Legacy name for ClaudeBot. Keep rules for backwards compatibility.

Anthropic expanded to three bots in early 2026. Sites that only reference ClaudeBot are now missing Claude-SearchBot (live search) and Claude-User (user-initiated fetching). If your robots.txt hasn't been updated since 2024, this almost certainly applies to your store.

The Default Magento robots.txt Problem

Magento's default robots.txt starts with a wildcard:

User-agent: *
Disallow: /index.php/
Disallow: /*?
Disallow: /checkout/
Disallow: /app/
...

This wildcard establishes a baseline that every bot inherits. If your deployment script, hosting provider, or a staging migration has added Disallow: / anywhere — AI bots are caught in it silently, with no error logged anywhere.

Check this right now. Open https://yourstore.com/robots.txt and look for Disallow: / on its own line. If it exists without an explicit Allow: / for each AI bot listed above it — every one of those bots is blocked.

# Quick check — if this returns output, you have a problem
curl -s https://yourstore.com/robots.txt | grep -n "^Disallow: /$"

Where Magento Serves robots.txt — Two Scenarios

Before editing, identify which method your store uses. Editing the wrong one has no effect.

Scenario A: Magento Admin (most common)

# Check if Magento manages robots.txt
bin/magento config:show design/search_engine_robots/default_robots

If it returns a value, edit via: Content → Design → Configuration → [Store view] → Edit → Search Engine Robots → Edit custom instruction of robots.txt

Scenario B: Static file in pub/

# Check if a static file exists and is being served
ls -la /var/www/html/pub/robots.txt
curl -I https://yourstore.com/robots.txt
# If no X-Magento headers appear, the file is served statically

Edit pub/robots.txt directly, or remove it to let Magento Admin take over.

Multi-store: Each store view can have its own robots.txt. If you run multiple stores on different domains, configure each store view separately in Admin → Design → Configuration.

The Complete robots.txt for Magento 2

Paste this as your full configuration. AI bot entries must appear before the wildcard User-agent: * block.

# ============================================================
# AI SEARCH & INDEXING BOTS — Always allow
# Blocking these makes your store invisible in AI search answers.
# ============================================================
User-agent: OAI-SearchBot
Allow: /

User-agent: Claude-SearchBot
Allow: /

User-agent: PerplexityBot
Allow: /

User-agent: Google-Extended
Allow: /

# ============================================================
# USER-INITIATED FETCHERS — Always allow
# ============================================================
User-agent: ChatGPT-User
Allow: /

User-agent: Claude-User
Allow: /

User-agent: Perplexity-User
Allow: /

# ============================================================
# TRAINING CRAWLERS — your choice
# Blocking does NOT affect search visibility.
# Change Allow to Disallow to opt out of training data collection.
# ============================================================
User-agent: GPTBot
Allow: /

User-agent: ClaudeBot
Allow: /

User-agent: anthropic-ai
Allow: /

User-agent: Applebot-Extended
Allow: /

# ============================================================
# TRADITIONAL SEARCH ENGINES
# ============================================================
User-agent: Googlebot
Allow: /

User-agent: Bingbot
Allow: /

# ============================================================
# ALL OTHER BOTS — standard Magento rules
# AI bots above are explicitly allowed before this wildcard.
# ============================================================
User-agent: *
Allow: /

# Magento paths — block from all crawlers
Disallow: /admin/
Disallow: /adminhtml/
Disallow: /api/
Disallow: /rest/
Disallow: /graphql
Disallow: /cron.php
Disallow: /var/
Disallow: /lib/
Disallow: /dev/
Disallow: /index.php/
Disallow: /*?SID=
Disallow: /*?___store=
Disallow: /checkout/
Disallow: /customer/
Disallow: /wishlist/
Disallow: /review/

# ============================================================
# SITEMAPS
# ============================================================
Sitemap: https://yourstore.com/sitemap.xml
Sitemap: https://yourstore.com/llms.txt

⚠️ Order is not optional. robots.txt uses first-match semantics per crawler. If User-agent: * with Disallow: / appears before the AI bot entries, those AI bots are permanently blocked — the rules below are never reached.

Four Mistakes That Block AI Bots

❌ Mistake 1 — Disallow: / left on from staging

Many Magento stores use Disallow: / on staging. This is frequently copied to production and never removed.

Common sources:

Magento Admin: Stores → Configuration → General → Design → Search Engine Robots
Manually edited pub/robots.txt copied from staging
CI/CD pipelines that sync the full staging filesystem to production
Managed hosts (Hypernode, Nexcess, Cloudways) applying restrictive defaults on new environments

❌ Mistake 2 — Wildcard block placed before AI bot rules

# ❌ WRONG — wildcard fires first, AI bot rules below it are ignored
User-agent: *
Disallow: /

User-agent: OAI-SearchBot
Allow: /  # ← never reached, bot already matched the wildcard above

# ✅ CORRECT — explicit AI rules appear before the wildcard
User-agent: OAI-SearchBot
Allow: /

User-agent: *
Disallow: /checkout/

❌ Mistake 3 — Using outdated Anthropic bot names

# Deprecated — no longer reflect Anthropic's bot infrastructure
User-agent: Claude-Web     # retired 2024
User-agent: Anthropic-AI   # retired 2024

# Current names (2026)
User-agent: ClaudeBot        # training
User-agent: Claude-SearchBot # live search index ← missing from most configs
User-agent: Claude-User      # user-initiated fetching ← missing from most configs

❌ Mistake 4 — robots.txt served from cache or static file

Some hosting setups bypass Magento when serving robots.txt:

Nginx static rule serves pub/robots.txt before Magento handles the request
CDN caching — Cloudflare or Fastly caches the old file with long TTLs
Varnish returns cached response without hitting the application

# Diagnosis — if no X-Magento headers, file is served statically
curl -I https://yourstore.com/robots.txt

Fix for Nginx — ensure this location block is present:

location = /robots.txt {
    try_files $uri $uri/ /index.php$is_args$args;
}

Fix for Cloudflare — purge cache for /robots.txt via dashboard, or add a Cache Rule to bypass caching for that path.

Verify the Fix

# Check all critical AI search bots have Allow: /
curl -s https://yourstore.com/robots.txt | grep -A1 -E \
  "OAI-SearchBot|Claude-SearchBot|PerplexityBot|Google-Extended"

# Check server logs to confirm bots are actually crawling
grep -Ei "OAI-SearchBot|Claude-SearchBot|PerplexityBot" \
  /var/log/nginx/access.log | tail -20

# Via AEO audit module — checks all bots + validates rule order
composer require angeo/module-aeo-audit
bin/magento setup:upgrade
bin/magento angeo:aeo:audit

# ✓ PASS  robots.txt — AI Bot Access
#         OAI-SearchBot ✓  Claude-SearchBot ✓  ChatGPT-User ✓
#         ClaudeBot ✓  Claude-User ✓
#         PerplexityBot ✓  Google-Extended ✓

# Multi-store — run per store view
bin/magento angeo:aeo:audit --store=de
bin/magento angeo:aeo:audit --store=fr

After robots.txt — What's Next

Fixing robots.txt is the access layer. Once AI bots can reach your store, the signals that determine whether you actually appear in AI answers are:

llms.txt — machine-readable index of your catalog that AI assistants parse in seconds → angeo/module-llms-txt
Product JSON-LD schema — structured markup that tells AI exactly what your products cost and where to buy them → checked by angeo/module-aeo-audit
AI product feed — structured feed required for ChatGPT Shopping eligibility → angeo/module-openai-product-feed

# See all 8 AEO signals and your complete score
bin/magento angeo:aeo:audit

FAQ

Q: Does blocking GPTBot affect ChatGPT recommendations?

No — but blocking OAI-SearchBot does. These are separate bots. GPTBot collects training data; OAI-SearchBot builds the index ChatGPT uses for search answers. Blocking GPTBot has no effect on whether your store appears in ChatGPT results. Blocking OAI-SearchBot removes you from ChatGPT search answers entirely.

Q: What is OAI-SearchBot and why does it matter more than GPTBot?

OAI-SearchBot is OpenAI's crawler that powers ChatGPT real-time search results and product recommendations. It determines whether your store appears in ChatGPT answers today. GPTBot collects training data for future model versions — its effects are long-term and indirect. Both should be allowed, but OAI-SearchBot is the one that determines your current search visibility.

Q: How do I check which AI bots are blocked in Magento 2?

curl https://yourstore.com/robots.txt | grep -i \
  'searchbot\|gptbot\|claude\|perplexity\|google-extended'

If nothing appears, bots may be blocked by a wildcard Disallow: / rule. The fastest automated check:

composer require angeo/module-aeo-audit
bin/magento setup:upgrade
bin/magento angeo:aeo:audit

It checks all bots, validates rule order, and reports exact status for each one.

Q: Should I allow training bots like GPTBot and ClaudeBot?

For most ecommerce stores, yes. Allowing training crawlers means your product descriptions and category content contribute to how AI models understand and describe products in your category — which indirectly improves recommendation quality over time. If you have legal or privacy reasons to opt out, block only the training bots (GPTBot, ClaudeBot, Applebot-Extended) — your search visibility is not affected.

Check all AI bots and 7 other AEO signals in one command — free, MIT licensed:

📦 Install AEO Audit Module
🌐 Free Web Self-Assessment

Originally published at angeo.dev

DEV Community: Ievgenii Gryshkun

Magento AI Brand Visibility: Does ChatGPT Recommend Your Store?

Why AI brand visibility matters for Magento merchants

How Magento AI brand visibility tracking works

Supported AI providers

The five visibility signals

What you get in the Magento admin

Automate it: CLI, cron and CI gates

Built to extend angeo/module-aeo-audit

Security & privacy

Installation

How to improve your AI brand visibility score

FAQ

The 4-Layer Magento 2 AEO Stack: Making Your Store Visible to ChatGPT, Claude & Gemini (2026)

Layer 1 — robots.txt: you're probably blocking the bots you want

Layer 2 — JSON-LD: Magento ships the wrong format and skips the one field that matters

Layer 3 — llms.txt: ship it, but not for the reason you've been sold

Layer 4 — ACP & UCP: the part that's actually about money

TL;DR priority order

llms.txt for Magento 2: Free vs Paid Modules (2026 Review)

TL;DR

Why this matters

What is llms.txt?

llms.txt vs sitemap.xml vs robots.txt

Does it improve SEO?

Magento 2 implementation approaches

1. Manual file (small stores)

2. Admin-driven modules (business teams)

3. Developer / automation-driven modules

Example structure

What surprised me during research

Key takeaway

Final thought

Shopify vs Magento for AI Commerce in 2026: Platform-Mediated vs Merchant-Controlled AEO

Key findings (as of May 2026)

The two paths to AI commerce visibility

The state of play: what each platform delivers

Shopify — platform-mediated AI distribution

Magento — Merchant-Controlled AEO

Real audit output — what Merchant-Controlled AEO looks like

Retrieval tests — what AI engines actually surface

Full capability comparison

Where Shopify's advantage is real

Platform-level distribution via ACP

Native AI attribution

Speed to AI visibility

Where Magento's advantage is real

Control and auditability — the Merchant-Controlled AEO position

Multi-store architecture

Open standards, no vendor lock-in

Data ownership

The gap neither platform fully solves

Which platform for which merchant

The real shift isn't Shopify vs Magento

Adobe Commerce Cloud now costs $40k/year. We migrated from Adobe Commerce to Magento Open Source — here's the honest breakdown

TL;DR

Why this conversation is happening now

What actually stays the same

What actually breaks — the technical reality

1. The row_id vs entity_id schema split

2. The B2B Suite trap

3. Adobe Sensei recommendation widgets

4. Page Builder content drift

5. Hosting migration is bigger than it sounds

The cost math — honest version

Decision framework

The one migration we didn't recommend

What I'd ask before migrating

The Magento multi-store bug every AI description generator has — and how we fixed it

The bug nobody talks about

The framework around the fix

The four-provider benchmark

Speed (avg per description)

Cost (per 1,000 descriptions, ~200 words each)

Quality (manual review of 200 samples)

Why Groq matters

Installation

Why it's open source

Key takeaways for Magento devs

Links

1. The `row_id` vs `entity_id` schema split