Key Takeaways
- There is no single AI shopping feed format. Google takes RSS 2.0 XML with a g: namespace, Perplexity reads that same Google specification, and OpenAI takes a delimited file in its own field names.
- Google's supplemental feed is an enrichment layer that merges onto your primary feed by id. OpenAI's file is a complete standalone catalog, not an overlay.
- OpenAI requires brand and treats gtin as optional, which is the reverse of what years of Google feed work teaches merchants to expect.
- OpenAI picks one parser for the entire upload and will not switch row to row, so a half-migrated file fails as a whole rather than losing a few products.
- The formatting differences are mechanical. The catalog underneath is the same data, and its accuracy is what actually decides whether you get recommended.
One Catalog, Three Destinations
A merchant with one product catalog and three AI surfaces to reach asks a fair question: how many feeds is this going to be?
Fewer than the vendor pitches suggest, and more work than the “just connect your store” pitches suggest. You need one catalog that is actually correct, and then between one and two files depending on where you want to show up. The formats are not interchangeable, and the differences are not cosmetic.
A file that Google accepts without complaint can be rejected outright by OpenAI. A product that has sat happily in Merchant Center for two years can be dropped from a ChatGPT upload over a column Google never asked about. Knowing where the specifications actually diverge is what stops you from doing the same job three times, or doing it once and assuming it landed everywhere.
Google Wants a Patch, Not a Catalog
Google’s format is RSS 2.0 XML with a namespace declaration, xmlns:g="http://base.google.com/ns/1.0", and it has worked that way for years. Every product attribute carries a g: prefix to separate it from the handful of elements RSS itself defines. Google’s RSS 2.0 specification is blunt about what happens if you forget: attributes without the prefix, “and any values they contain will be ignored.” No error, no warning. The data just does not arrive.
The part that catches people is the split between a primary and a supplemental feed.
Your primary feed is the entire catalog, and Google expects it to stay entire. From the same page: “If you remove a product from your RSS product data source it will be removed from Google Merchant Center.” It is a snapshot, not a changelog.
A supplemental feed works the other way round. Each item carries the g:id that matches a row in your primary feed, plus only the attributes you are adding. It cannot create a product that does not already exist. It does not need price, availability or an image, because those already live on the primary feed and stay there.
That distinction is the whole reason the supplemental feed is the sane place to put conversational attributes. product_highlight, product_detail, question_and_answer and variant_option are additions to rows that already work. You are not rebuilding your catalog to serve AI Mode. You are attaching more description to products Google already has, which is also why supplemental feeds became the cheap lever they are now.
Perplexity Reads the Feed You Already Have
Perplexity is the easy one, and merchants keep making it hard for themselves.
Perplexity does not define a proprietary format. It ingests the Google Shopping product data specification, so the file reaching Perplexity is, for most merchants, the file already reaching Google. Enrolment happens through the Perplexity Merchant Program, and the route in runs through your existing Merchant Center data rather than a second build. We have written up the application itself in detail.
The useful consequence: every improvement you make for Google lands on Perplexity at the same time, with no second file to maintain.
There is one caveat, and it is not a formatting problem. Perplexity weights GTIN more heavily than Google does, because it uses the identifier to collapse ten retailers selling the same item into a single product card and then chooses between them. A missing identifier will not break your file. It quietly removes you from a comparison you should have been part of.
Worth saying plainly, because plenty of tools imply otherwise: nobody can invent that number for you. A GTIN is assigned by the manufacturer or by GS1, and a fabricated one belongs to somebody else’s product. The genuinely useful thing software can do here is tell you exactly which products are missing one, so you can go and source the real value.
ChatGPT Wants the Whole Thing, in Its Own Words
This is where the actual work sits.
OpenAI’s product feed is not an enrichment layer. It is a complete, standalone file with its own field names, its own required list and its own upload path. And the names are not Google’s. It is item_id, not id. url, not link. image_url, not image_link. OpenAI’s products specification states that g:-prefixed XML names are not supported, and that JSON, spreadsheet, XML, RSS and Atom sources are not part of the file upload path at all. You export a delimited file or you do not upload.
OpenAI does publish a Google-compatible route, which accepts a delimited export using Google’s column names and maps it across. That is how most merchants will start, and it is a reasonable place to start. But the two routes do not ask for the same things, and this is the detail that trips people.
On the Google-compatible path you need eight columns on every row: id, title, description, link, image_link, availability, price and brand. On OpenAI’s native schema the required list is longer and structurally different, adding eligibility flags such as is_eligible_search and is_eligible_checkout, plus target_countries.
Notice what appears on both lists. Brand. In OpenAI’s own schema brand is required and capped at 70 characters, while gtin is optional. After years of Google feed work that ordering feels backwards, and it is the single most common surprise in a first ChatGPT upload: the product with a perfect GTIN and an empty brand column is the one that vanishes. On the Google-compatible path the identifier rule reappears in a different shape, where a valid gtin or mpn is required unless you set identifier_exists to no, and OpenAI is clear that no is for products that genuinely have no identifier.
One more mechanic is worth knowing before you upload anything. OpenAI samples records from your files and selects a single parser for the whole upload. It checks its own schema first, falls back to the Google-compatible profile only if that profile accepts a sampled record from every file, and it does not switch parsers row to row. A half-migrated file that mixes both naming conventions does not get half accepted. It gets read by one parser and fails against the other’s fields. The field level requirements deserve their own pass before you send anything.
The format is a rendering problem. The catalog underneath is the same data on every surface, and it is either accurate or it is not.
What Every AI Shopping Feed Needs, and What Only One Surface Wants
Take the syntax away and the overlap is larger than the divergence.
All three want a real brand string rather than a blank or a store name. All three want a price with a currency code attached. All three want availability that reflects what is actually in the warehouse this morning. All three cap the title at 150 characters and want it to describe the product rather than perform for a keyword tool.
The surface-specific layer is thinner than it looks. Google wants conversational attributes delivered in a supplemental feed and merged by id. Perplexity wants nothing extra built, but it will punish a missing identifier harder than Google does. ChatGPT wants a complete file in OpenAI’s own field names, with brand mandatory and its recommended fields, q_and_a and reviews among them, carrying the enrichment that Google puts in question_and_answer.
Which reframes the original question. It was never “how many feeds do I need.” It is “how many times am I willing to fix the same missing colour, the same absent brand, the same 200 character title.” Rendering one clean catalog into three shapes is mechanical work that software should be doing. Getting the catalog clean is the part that decides everything downstream, and it is the part most merchants have never had a tool for.
Conclusion
Three AI storefronts, two file formats, one catalog. Google takes a patch that merges by id, Perplexity reads the Google specification you already produce, and OpenAI takes a complete delimited file with its own vocabulary and its own required fields. Learn where those three diverge and the plumbing stops being mysterious.
What does not change is the data. Every one of these surfaces is reading structured fields to work out what your product is, and a gap in your catalog is a gap on all three at once. That is the work worth automating, and it is what UCP Radar does: it reads your Merchant Center data, scores every product from 0 to 100 for AI readiness, fills the attributes that are genuinely missing while leaving identifiers and brand alone, and renders the result into the formats each surface expects. You still register the feeds yourself, because no tool submits on your behalf, and nobody can promise you a ranking on any of these surfaces. What you can control is whether your products are readable at all. Scan your feed and see which of the three you are currently failing.
Frequently Asked Questions
You need one accurate catalog and up to two files. Google takes an RSS 2.0 XML supplemental feed that merges onto your primary feed by id, and Perplexity ingests the Google Shopping specification, so those two share the same work. ChatGPT is the exception, because OpenAI takes a complete standalone file in its own field names rather than an enrichment layer.
RSS 2.0 XML with the Google namespace declaration xmlns:g="http://base.google.com/ns/1.0". Every product attribute carries a g: prefix, and Google states that attributes missing the prefix, along with any values they contain, are ignored during processing. A supplemental feed contains the matching g:id plus only the attributes you are adding.
No. Perplexity ingests the Google Shopping product data specification rather than a proprietary format, which is why merchants reach it through their existing Merchant Center data after enrolling in the Perplexity Merchant Program. The one practical difference is that Perplexity leans harder on GTIN, because it uses the identifier to group retailers selling the same item into a single product card.
Brand. In OpenAI's own product schema brand is a required field capped at 70 characters, while gtin is optional. On OpenAI's Google-compatible upload path, a valid gtin or mpn is required unless identifier_exists is set to no. Merchants who assume Google's identifier rules carry over are usually surprised by which field actually drops the row.
Not usefully. OpenAI does not accept XML, RSS or Atom sources on its file upload path, and states that g:-prefixed names are not supported. It samples records, selects a single parser for the whole upload, and does not switch parsers row to row, so a file mixing both naming conventions fails against whichever parser is not chosen.
