Should Shopify merchants rely on /products.json to show their full catalogue to AI tools?
You may have seen `/products.json` suggested as a simple way for an AI tool to read a Shopify catalogue.
It is simple. Add it after your domain, open the URL, and you may see product titles, descriptions, variants, images, and more.
But you should not treat it as the full or authoritative answer for AI shopping channels.
Shopify says Shopify Catalog is its authoritative product-data feed for agentic channels. It is separate from discovery files such as `/agents.md`, `/llms.txt`, and `/llms-full.txt`. Those files can help a system understand your store, but they do not replace Shopify Catalog.
That distinction matters if you want a customer to find a real, purchasable product through an AI assistant.
What `/products.json` is good for
`/products.json` is a public storefront endpoint. On many stores, it exposes a readable product list without requiring a login.
Third-party documentation reports that its product data can include:
- Product ID and handle
- Title and HTML description
- Vendor, product type, and tags
- Product options and variants
- Images
That makes it useful for a quick check.
Try this now: open `yourstore.com/products.json` in a browser. Search the page for the title of a product you know well.
If you cannot find it, that is useful information. The product may not be public in the way you expected, or the endpoint may not give you the catalogue view you had in mind.
Even if you do find it, do not stop there.
Third-party documentation also reports that `/products.json` leaves out some store context. That can include metafields, collections, meta titles, orders, customers, and live inventory counts. Some of those omissions are sensible. A public product endpoint should not expose customer or order data.
But for AI discovery, missing context can matter. A metafield may hold a material, compatibility detail, size guide, care instruction, or product fact that makes the difference between a useful recommendation and a vague one.
The quiet problem with a large catalogue
The biggest practical risk is thinking you read every product when you did not.
We ran into this while building our own `llms.txt` builder. Shopify’s `/products.json` returned at most 250 products per page. A catalogue read could look complete while quietly missing everything after that first page.
We had to handle pagination ourselves.
Say your store has 400 products. A tool that fetches one page might report that it found 250 products. It may then write a perfectly tidy catalogue summary based on only those products.
The missing 150 products are not necessarily broken. They may simply never have been requested.
You can check this in under a minute. Open:
`yourstore.com/products.json?limit=250&page=1`
Then try:
`yourstore.com/products.json?limit=250&page=2`
If the second URL returns products, a one-page read was incomplete.
Do not assume every tool handles this correctly. Ask what it reads, how it paginates, and whether it tells you when a read is partial.
Shopify’s supported catalogue path is different
For supported AI channels, Shopify says Shopify Catalog automatically makes eligible products discoverable. It supplies structured product data including titles, descriptions, options, images, prices, availability, and other attributes.
Shopify also says it continuously updates inventory and pricing.
That is the job an authoritative commerce feed needs to do. Product data is not just copy. A customer needs the right variant, a current price, and a product that is actually available.
So the first question is not, “Does `/products.json` exist?”
It is, “Are the products I want found and sold through AI eligible for Shopify Catalog?”
Check Shopify’s agentic storefront product settings and review the products you expect to be available. Pay close attention to products that are hidden, unavailable, or handled differently from the rest of your catalogue.
Shopify Catalog is not a promise that any product will appear in every AI response. Shopify is clear about that. Inclusion does not guarantee an answer, a ranking position, or display in every connected channel.
It does mean you are using the product-data path Shopify identifies for those channels.
What about the Storefront API?
If you are building your own catalogue reader, use Shopify’s documented Storefront API rather than treating `/products.json` as a permanent integration surface.
Shopify’s current Storefront API is GraphQL-only. Its documented endpoint follows this pattern:
`https://{store_name}.myshopify.com/api/2026-01/graphql.json`
Shopify says there is no REST API for storefronts.
The Storefront API `products` query is built for a paginated product list. It supports controls such as `first`, `after`, filtering, sorting, and product-search queries.
GraphQL pagination still needs care. Shopify documents a maximum of 250 resources per request. For more, your code needs to keep requesting pages with the cursor fields `hasNextPage` and `endCursor`.
In plain terms: request a page, check whether another page exists, save the cursor, and repeat until it does not.
If you are not writing the integration yourself, this is still worth knowing. It gives you a simple question for a developer or software vendor:
How do you retrieve products after the first 250?
A clear answer should mention cursor pagination, not a hope that one request covers the store.
Use each thing for its job
There is no need to make one URL do every job.
Use Shopify Catalog for the product data Shopify provides to supported agentic channels.
Use your product pages for the full customer-facing details: clear titles, useful descriptions, images, options, and policies.
Use public discovery files such as `llms.txt` as supporting store context, not as a replacement product feed.
And use `/products.json` carefully. It can be a handy public diagnostic. It can help a tool get a first look at your catalogue. But it is not Shopify’s documented Storefront API, it may omit useful fields, and a single page may not represent your full range.
The quiet next step is to open `/products.json?page=2` on your own store. If it contains products, make sure any catalogue reader you use knows how to keep going.