Shopify stores can generate AI-readable product feeds via native GraphQL endpoints and admin CSV exports, while WooCommerce stores require third-party plugins for automated feeds. Custom sites control feed architecture but must explicitly add structured outputs for AI agents.
AI agents consume product data through three primary channels: structured schema markup on product pages, API endpoints, and pre-generated feeds. Feeds offer the highest reliability because they eliminate rendering issues, JavaScript dependencies, and template variations that break parsers. Learn more in our platform discoverability cost comparison.
The feed generation approach your platform uses determines whether AI agents can easily consume your catalog at scale.
Why Feed Generation Matters for AI Agent Discoverability
AI agents prefer structured feeds over HTML scraping because feeds provide clean, consistent data without parsing complexity. Feed-based product discovery runs faster and produces fewer data quality errors.
According to Google’s feed requirements documentation, feeds should include identifiers like GTIN and product-level availability for better matching. Agents using feeds can process thousands of products in seconds compared to minutes for HTML parsing.
Feeds also reduce the computational load on AI agent platforms. Instead of rendering JavaScript and parsing HTML structures, agents simply parse structured JSON or XML. This efficiency allows AI platforms to index more products more frequently.
When your product data is available in feeds, AI agents can update their product databases more often. HTML scraping typically runs weekly or monthly due to resource constraints. Feed-based updates can occur daily or hourly, ensuring AI agents have current pricing, availability, and product details.
Shopify Feed Generation: Native vs App-Dependent
Shopify provides three native feed mechanisms:
- Products API GraphQL endpoint at
https://{store}.myshopify.com/api/2026-04/graphql.json - Products CSV export through Admin panel (manual trigger only)
- Shopify Flow for scheduled feed generation (paid plan only)
Native Capabilities
Shopify’s GraphQL API exposes product data natively. The API includes product titles, descriptions, variants, pricing, inventory, availability, images with alt text, and metafields for custom attributes. The official GraphQL API documentation lists available fields and endpoints.
However, the API requires authentication and rate limiting. AI agents without OAuth tokens cannot access it directly. This makes the API useful for agent platforms with integrations, but not for direct agent consumption. See our Shopify vs WooCommerce vs custom discoverability guide.
The GraphQL endpoint supports querying products with filters, pagination, and field selection. You can fetch specific data types like product variants, images, prices, and inventory. This flexibility makes it powerful but also complex to configure correctly for agent consumption.
Shopify’s rate limits depend on your plan. Basic Shopify allows 80 GraphQL cost points per minute, while Shopify Plus allows 1000. Feed generation queries often hit these limits on larger catalogs, making API-based feeds impractical for stores with thousands of products.
CSV Export Limitations
The native CSV export works but has critical limitations:
- Manual trigger only (no automated scheduling)
- Excludes metafields by default
- Limited to products (variant export requires extra steps)
- Flat structure (harder for nested product data)
- No real-time updates (manual download required)
The CSV export downloads to your computer. You must then upload it to a server or feed service manually. This manual process breaks automation and makes daily feed updates impractical.
The CSV format lacks nesting. Variant products export as separate rows without clear parent-child relationships. AI agents must infer variants based on SKU patterns or duplicate titles. This ambiguity leads to incorrect product recommendations.
Metafields contain custom product data like material, season, or fit preferences. These fields help AI agents match products to user intent. The native CSV export excludes them unless you manually add columns, which requires Shopify admin access each time.
Shopify Flow for Automation
Shopify Flow can automate feed generation but requires a Shopify plan or higher. You can create workflows that trigger on product updates, inventory changes, or scheduled intervals. The workflow can call a webhook or export to a file storage service.
Shopify Flow adds overhead and complexity. You must configure triggers, actions, and error handling. Feed failures require manual intervention or additional Flow steps for retries. Many store owners prefer dedicated feed apps that handle this complexity automatically.
Third-Party Feed Apps
Popular Shopify feed apps include:
- Google Shopping Feed App by Shopify (free)
- Product Feed Manager by Simprosys (paid)
- Data Feed Watch (paid)
These apps generate feeds in multiple formats: XML, JSON, CSV, and the emerging llms.txt standard. They handle automated scheduling, variant-level feeds, multi-language feeds, feed-level rule configuration, and custom field mapping.
Feed apps typically install via the Shopify App Store with one-click setup. You select products, choose feed formats, and configure scheduling. The app handles GraphQL API calls, rate limiting, and error retries automatically.
Most feed apps generate feeds that upload to their servers. Your AI agent endpoints reference these external URLs. This approach adds a dependency on the app’s uptime but simplifies your infrastructure.
Some feed apps offer advanced features like field-level transformations, currency conversion, and feed filtering by product tags or collections. These capabilities help you create specialized feeds for different AI agent platforms without custom development.
WooCommerce Feed Generation: Plugin-Dependent by Default
WooCommerce requires plugins for feed generation. The platform exposes:
- REST API at
/wp-json/wc/v3/products(requires API keys) - Admin manual CSV export (limited to products)
Core Plugin Requirements
Three WooCommerce plugins handle the majority of feed generation:
- Product Feed Manager by XT Woo (free + pro)
- WP All Export (paid)
- WooCommerce Google Product Feed by AdTriba (free + premium)
Feed Capabilities by Plugin
Product Feed Manager generates Google Merchant Center XML, Facebook Catalog XML, custom JSON feeds, scheduled generation, and variant-level feeds. Configuration complexity is medium. You set up feed templates, map WooCommerce fields to feed fields, and configure cron schedules.
The free version covers basic Google Shopping feeds with standard fields. The pro version adds custom field mapping, multi-currency support, and advanced scheduling. Many stores start with the free version and upgrade as needs grow.
WP All Export offers any CSV/XML/JSON structure, drag-and-drop field mapping, cron-based automation, database query filters, and multi-feed generation. Configuration complexity is high. Technical knowledge required for complex feeds.
WP All Export is not WooCommerce-specific. It exports any WordPress data. This flexibility makes it powerful for complex feed structures but also more difficult to configure. You must understand both WooCommerce data structure and target feed schemas.
The drag-and-drop interface maps WooCommerce fields to feed columns visually. You can add filters to export only specific products, categories, or attributes. Cron jobs handle automation, but you configure them through WordPress hosting or server cron rather than the plugin interface.
WooCommerce Google Product Feed provides Google Shopping XML only, basic variant support, daily generation, and category mapping. Configuration complexity is low but flexibility is limited. Plug-and-play but limited to Google Shopping requirements.
This plugin focuses exclusively on Google Merchant Center compliance. It handles category mapping automatically based on your product categories. Feed generation runs once daily via WordPress cron. No manual configuration beyond initial setup.
The plugin lacks custom field support. If your products have WooCommerce attributes or meta fields that AI agents need, this plugin will not include them. You must use a more flexible plugin for custom requirements.
Hosting and Caching Dependencies
WooCommerce feed performance depends on hosting configuration. Robust hosting helps ensure feed generation completes within reasonable timeframes for larger catalogs.
Shared hosting environments often have PHP execution time limits around 30 seconds. Feed generation queries that exceed this limit fail with timeout errors. Stores with thousands of products on shared hosting frequently encounter these failures.
VPS or dedicated hosting provides more resources and flexible timeout settings. You can increase PHP execution time limits, allocate more memory, and configure database query timeouts specifically for feed generation.
WordPress cron reliability also affects feed generation. Shared hosts often disable real cron jobs and use simulated cron based on site traffic. Low-traffic stores may miss scheduled feed runs. VPS hosting allows real cron jobs via server cron configuration.
CDN caching for feed endpoints reduces server load and improves feed delivery speed. Feed files change infrequently (hourly or daily), making them ideal for CDN caching. Configure cache headers with long TTLs but implement cache invalidation when feeds update.
Recommended hosting for reliable feed generation includes managed WooCommerce hosting and VPS providers with cron control. These services optimize WordPress performance for ecommerce workloads and provide tools for reliable feed automation.
WordPress-Specific Considerations
WooCommerce feeds run within WordPress, which introduces WordPress-specific challenges. Plugin conflicts can break feed generation. Updates to WooCommerce or feed plugins may require feed template reconfiguration.
WordPress multisite installations add complexity. Each subsite requires separate feed configuration. Feeds must generate per-subsite URLs, and WordPress multisite routing must correctly serve feed requests.
WordPress security plugins sometimes block feed access by mistaking feed crawlers for bots. Whitelist AI agent user agents or feed URLs in security plugin settings. Ensure robots.txt allows feed access and security rules do not block legitimate feed requests.
Custom Platforms: Full Control But High Implementation Burden
Custom ecommerce platforms have complete control over feed architecture. This flexibility comes with implementation complexity.
Feed Architecture Options
Custom platforms typically implement feeds through:
- Static file generation (build-time feed creation)
- Dynamic feed endpoints (on-demand generation)
- Message queue-based generation (async feed updates)
Static File Generation
Popular with static site generators and build processes. Advantages include feed availability even if database is offline, version control for feed schema changes, and no runtime overhead. Limitations include feeds only updating on redeploy.
Static generation works well for catalogs that change infrequently. Build processes like Next.js static export, Hugo builds, or Gatsby generate feed files during the build pipeline. CI/CD triggers builds when product data updates.
The tradeoff is stale data between builds. If a product goes out of stock after the last build, AI agents continue recommending it as available. This gap ranges from hours to days depending on deployment frequency.
Static feeds work best when combined with inventory status API calls. AI agents fetch the static feed for product data and make real-time API calls for current availability. This hybrid approach balances performance and freshness.
Dynamic Feed Endpoints
Generate feeds on-demand with endpoints like /feeds/products.json. Advantages include real-time data and scalability via CDN. Limitations include added server load and required caching strategy.
Dynamic endpoints query your database and render feed responses in real-time. Every feed request triggers database queries, JSON serialization, and HTTP response generation. This approach provides fresh data but scales poorly without caching.
CDN caching solves the scalability problem. Cache feed responses at the edge with appropriate cache headers. Implement cache invalidation when products update. Most platforms use webhooks, message queues, or scheduled jobs to purge CDN caches.
Cache invalidation timing affects data freshness. Invalidate too often and you lose CDN benefits. Invalidate too rarely and AI agents see stale data. Hourly invalidation works for most stores, while fashion or flash-sale stores may need more frequent updates.
Message Queue-Based Generation
Asynchronous feed updates triggered by data changes. Advantages include near real-time feed updates. Limitations include highest implementation complexity and DevOps overhead.
Product updates, inventory changes, or price modifications trigger messages to a queue (Redis, RabbitMQ, AWS SQS). Background workers consume messages, regenerate affected feeds, and update CDN caches. This approach provides near real-time updates without blocking user requests.
Message queues add infrastructure complexity. You must run and maintain queue services, background workers, and failure handling. If queues back up or workers fail, feeds fall behind and AI agents see stale data.
This approach justifies complexity for large catalogs with frequent updates. Stores with tens of thousands of products and multiple inventory warehouses benefit from granular feed updates. Smaller stores often choose simpler static or dynamic approaches.
Common Implementation Gaps
Despite full control, custom platforms must explicitly include required fields and formats to pass AI agent feed quality checks. Common issues include missing required fields like GTIN or product_type, inconsistent date formats, no variant-level feeds, missing images or broken image URLs, and feed authentication that blocks public access.
Missing required fields causes agents to skip products or recommend incomplete information. Google’s feed requirements specify GTIN, availability, price, and condition as required fields. AI agents expect similar fields for reliable matching.
Date format inconsistencies break feed parsing. Some feeds use ISO 8601 format (2026-06-16T10:00:00Z), others use Unix timestamps, and others use custom formats. Agents parse dates using strict format expectations. Mixed formats cause parsing failures.
Variant-level feeds help agents recommend specific products. If you only export parent products, agents cannot distinguish between sizes, colors, or other variants. Users receive vague recommendations instead of specific product matches.
Missing images or broken image URLs reduce recommendation quality. Agents use images for product understanding and matching. 404 image URLs or missing alt text signals low-quality data to agents, affecting recommendation priority.
Feed authentication blocks public access. Agents prefer open feeds without login requirements. If you require API keys or authentication, create separate public feeds with basic product information. Restrict sensitive feeds to authenticated partners only.
Feed Format Comparison: XML vs JSON vs llms.txt
AI agents consume three primary feed formats:
XML Feeds
Example usage: Google Shopping, Facebook Catalog
<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:g="http://base.google.com/ns/1.0">
<channel>
<item>
<g:id>SKU123</g:id>
<g:title>Product Name</g:title>
<g:description>Description</g:description>
<g:link>https://store.com/product</g:link>
<g:image_link>https://store.com/images/123.jpg</g:image_link>
<g:price>29.99 USD</g:price>
<g:availability>in stock</g:availability>
<g:gtin>00123456789012</g:gtin>
</item>
</channel>
</rss>
Agent compatibility: Widely supported by major agent platforms Pros: Widely supported, schema validation available Cons: Verbose, larger file sizes, nested parsing complexity
XML feeds use standard RSS 2.0 format with namespace extensions. Google’s product feed specification defines required and optional fields. Schema validators like Google’s Merchant Center feed validator check compliance automatically.
XML verbosity increases file sizes. Nested structures require recursive parsing. Older agent platforms prefer XML due to成熟 library support. Newer platforms often choose JSON for simpler parsing.
JSON Feeds
Example usage: Custom integrations, modern agent platforms
{
"version": "1.0",
"products": [
{
"id": "SKU123",
"title": "Product Name",
"description": "Description",
"url": "https://store.com/product",
"images": ["https://store.com/images/123.jpg"],
"price": {
"amount": 29.99,
"currency": "USD"
},
"availability": "in_stock",
"identifiers": {
"gtin": "00123456789012",
"sku": "SKU123"
}
}
]
}
Agent compatibility: Supported by most modern agent platforms Pros: Compact, easy parsing, native to modern languages Cons: No universal schema standard (custom structures common)
JSON feeds use custom schemas defined by each platform. Google Shopping accepts JSON-LD structured data embedded in HTML, but external JSON feeds use platform-specific formats. This lack of standardization requires agent platforms to support multiple JSON schemas.
JSON’s native mapping to programming languages simplifies parsing. JavaScript, Python, and other modern languages parse JSON into objects with one line of code. This simplicity makes JSON the default choice for new agent platforms.
JSON feeds are more compact than equivalent XML feeds. Reduced file sizes improve download speeds and reduce bandwidth costs. For large catalogs with tens of thousands of products, JSON feeds are significantly smaller than XML alternatives.
llms.txt
Example usage: AI agents with LLM-based parsing (ChatGPT, Claude, Perplexity)
# Products Feed
## SKU123: Product Name
- URL: https://store.com/product
- Price: $29.99 USD
- Description: Product description
- Images: https://store.com/images/123.jpg
- Availability: In stock
- GTIN: 00123456789012
- Brand: Brand Name
- Category: Electronics > Audio
## SKU124: Product Variant
- Parent: SKU123
- Variant: Color: Black, Size: Large
- Price: $34.99 USD
- SKU: SKU124-BLK-L
Agent compatibility: Emerging support among AI-native agents (llms.txt is a newer format) Pros: Human-readable, LLM-native, no parsing errors Cons: Non-standard format, limited tooling, large file sizes for big catalogs
llms.txt uses plain text formatting that LLMs can read directly without parsing. Agents use natural language understanding to extract product information. This approach eliminates parsing errors caused by malformed JSON or XML.
The format lacks standardization. Different platforms use different field ordering, naming conventions, and structures. Agents must handle llms.txt variations, adding complexity to feed ingestion.
llms.txt files become large for big catalogs. Plain text is less compact than JSON or XML. Stores with thousands of products generate multi-megabyte llms.txt files that take time to download and process.
Despite these limitations, llms.txt adoption grows because it simplifies agent development. LLM-based agents can understand llms.txt without custom parsers, lowering integration barriers.
Feed Generation Performance Guidance
Feed generation speed and reliability vary by implementation:
- Static generation is fastest but lacks real-time updates
- WooCommerce performance heavily depends on hosting quality
- Shopify app-based feeds add latency but scale reliably
- Custom platforms achieve best performance when implemented correctly
For catalogs above 10,000 products, consider static generation with CDN hosting to serve feeds quickly. Static files never time out, scale infinitely via CDN, and eliminate server load during feed requests.
Dynamic endpoints require caching strategies. Cache feeds at the CDN edge with appropriate TTLs. Implement cache invalidation when products update. Monitor cache hit rates to optimize caching configuration.
Database query optimization affects dynamic feed performance. Use indexes on frequently queried fields like product_id, sku, and availability. Avoid N+1 queries that fetch related data individually. Batch queries or use GraphQL nested field selection.
Feed generation timeouts cause incomplete feeds. AI agents that encounter incomplete feeds may skip entire catalogs or produce incorrect recommendations. Set generous timeouts for feed generation, implement retry logic, and log failures for monitoring.
Monitor feed generation performance with metrics like generation time, feed size, and error rates. Alert on performance degradation or failures. Performance issues compound as catalogs grow, making monitoring essential.
What Your Platform Needs for AI Agent Feed Success
Minimum Requirements (Non-Negotiable)
- Automated feed generation: At least daily, preferably hourly
- Variant-level products: Each size/color as separate feed item
- Product identifiers: GTIN, SKU, or MPN for most products
- Image completeness: Every product has at least one accessible image with alt text
- Stock status: Real-time availability (in stock, out of stock, pre-order)
- Price accuracy: Current prices with currency
- Feed URL: Publicly accessible, no authentication required
Automated feeds ensure AI agents always have current data. Manual feeds quickly become outdated, causing agents to recommend unavailable products or incorrect prices. Schedule feed generation at least daily, hourly for catalogs with frequent updates.
Variant-level feeds enable specific recommendations. If a user asks for size large and color black, agents need variant data to match the request. Parent-only feeds force agents to make assumptions, leading to mismatches.
Product identifiers like GTIN help agents match products across sources. Agents compare products from multiple stores to find the best option. Without consistent identifiers, matching becomes unreliable.
Complete images with alt text improve agent understanding. Images help agents identify products, especially visually similar items. Alt text provides descriptions that agents use for semantic matching.
Real-time stock status prevents recommending unavailable products. Agents checking stock via API calls provide the most accurate availability. Feed-based stock status works if feeds update frequently, ideally hourly.
Accurate prices with currency enable cost comparisons. Agents compare prices across stores to find the best deal. Incorrect prices lead to poor recommendations and user frustration.
Public feed URLs without authentication maximize agent access. Agents prefer open feeds. If authentication is necessary, create separate public feeds with basic information and restrict sensitive feeds to authenticated partners.
Recommended Enhancements
- Multi-format feeds: Offer XML, JSON, and llms.txt simultaneously
- Incremental updates: Feed only changed products to reduce bandwidth
- CDN caching: Serve feeds from edge locations
- Feed versioning: Maintain feed history for debugging
- Custom field mapping: Allow AI agents to request specific fields
- Feed validation: Self-test feed before publishing
- Monitoring alerts: Notify on feed generation failures
Multi-format feeds maximize agent compatibility. Some agents prefer XML, others JSON. llms.txt serves LLM-based agents. Generating all formats ensures broad support without requiring agents to adapt to your format.
Incremental updates reduce bandwidth and processing time. Instead of regenerating entire feeds for small changes, generate incremental feeds containing only modified products. Agents request the base feed once, then pull incremental updates as needed.
CDN caching improves feed delivery speed and reduces server load. Feeds change infrequently, making them ideal for CDN caching. Configure appropriate cache headers and implement cache invalidation when feeds update.
Feed versioning helps debug issues. Keep past feed versions for at least 30 days. When agents report problems, compare current and past feeds to identify changes causing issues.
Custom field mapping allows agents to request specific data. Some agents need only basic fields like title and price. Others require detailed attributes like material, dimensions, or fit preferences. Customizable feeds serve diverse agent needs efficiently.
Feed validation catches errors before agents encounter them. Validate feeds against schema requirements, check for required fields, verify image URLs return 200 status, and test feed parsing. Automated validation prevents bad feeds from reaching agents.
Monitoring alerts notify you of feed failures. Feed generation errors, timeouts, or validation failures should trigger alerts. Quick response minimizes downtime and prevents agents from ingesting bad data.
Platform-Specific Action Items
Shopify Stores:
Validate your feed structure with a feed validator.
- Install a feed app if not already using one
- Enable variant-level feeds (check app settings)
- Map metafields to feed output
- Configure hourly generation schedule
- Test feed URL accessibility (curl command)
- Add llms.txt format if app supports it
Shopify store owners should start with a feed app that supports multiple formats. Configure the app to include all required fields. Set up hourly generation to keep feeds current. Test feed URLs to ensure public accessibility.
Metafields contain valuable custom data that helps agents match products to user intent. Map metafields to feed output fields so agents can access attributes like material, season, or fit preferences.
Hourly generation balances freshness and resource usage. Daily generation may cause agents to recommend outdated products for 24 hours. Hourly updates reduce this gap while avoiding excessive resource consumption.
WooCommerce Stores:
- Install Product Feed Manager or WP All Export
- Use hosting suitable for feed generation
- Configure cron job for automated generation
- Set up CDN caching for feed endpoint
- Validate feed against Google Shopping requirements
- Monitor feed generation logs for errors
WooCommerce store owners should evaluate plugin options based on customization needs. Product Feed Manager offers good balance of features and ease of use. WP All Export provides maximum customization but requires technical knowledge.
Hosting quality directly affects feed generation reliability. Upgrade from shared hosting if feed timeouts occur. VPS or managed WooCommerce hosting provides resources for reliable feed generation.
Configure real cron jobs on your server instead of relying on WordPress simulated cron. Real cron runs reliably regardless of site traffic. Set cron to trigger feed generation at your desired frequency.
CDN caching reduces server load and improves feed delivery speed. Many WordPress hosts include built-in CDN options. Third-party CDNs like Cloudflare also work. Configure cache rules for feed URLs with appropriate TTLs.
Custom Platforms:
- Implement at least one public feed format (JSON recommended)
- Add feed generation to CI/CD pipeline (static) or API endpoints (dynamic)
- Include all required fields (gtin, price, availability, images)
- Set up CDN caching for dynamic feeds
- Implement cache invalidation on product updates
- Add monitoring for feed uptime and performance
Custom platform developers should choose feed architecture based on update frequency and catalog size. Static generation works well for infrequent updates. Dynamic endpoints suit catalogs with frequent changes.
Implement JSON as the primary feed format. JSON is compact, widely supported, and easy to parse. Add XML and llms.txt formats if specific agent platforms require them.
Include all required fields in feed schema. Use GTIN, SKU, or MPN for product identification. Provide price with currency, availability status, and image URLs with alt text.
Cache dynamic feeds at the CDN edge. Set cache headers with appropriate TTLs. Implement cache invalidation when products update. Webhooks or message queues trigger cache purges.
Monitor feed performance and availability. Track generation time, feed size, error rates, and uptime. Alert on performance degradation or failures. Monitoring catches issues before they affect agent ingestion.
Feed Generation Cost Comparison
Total monthly cost for robust AI agent feed generation:
| Platform | Feed Cost | Additional Costs | Notes |
|---|---|---|---|
| Shopify | $29 (app) | Shopify plan upgrade optional | App required for automation |
| WooCommerce | $0 (free plugin) | Hosting tier dependent | Free plugins cover basic needs |
| WooCommerce (pro plugin) | $29 | Hosting tier dependent | Paid options add advanced features |
| Custom | $0 (dev time) | CDN $5, hosting variable | Dev time varies: 4-16 hours |
Note: Custom platform costs exclude initial development investment.
Shopify store costs center on feed app subscriptions. Basic apps cost $29 monthly. Advanced apps with multi-format support and custom field mapping cost $49-99 monthly. Shopify plan upgrades provide Shopify Flow for automation but cost extra.
WooCommerce store costs depend on hosting quality. Free feed plugins require no subscription, but robust hosting costs $20-50 monthly for VPS or managed hosting. Paid feed plugins add $29-49 monthly for advanced features.
Custom platform costs exclude initial development investment. Ongoing costs include hosting and CDN. Monthly hosting costs vary widely based on infrastructure choices. CDN costs are minimal for feed delivery due to infrequent updates.
Development costs represent the largest expense for custom platforms. Simple JSON feed endpoints take 4-8 hours to implement. Multi-format feeds with caching and monitoring take 12-16 hours. Development costs are one-time but require ongoing maintenance.
Feed Quality Validation Checklist
Before deploying feeds, validate against this checklist:
- Feed URL is publicly accessible (no login required). Validate with product feed tools.
- Feed returns HTTP 200 status
- Feed loads in under 5 seconds for 1,000 products
- All products have at least one image URL
- All image URLs return valid images (not 404s)
- Most products have GTIN, SKU, or MPN
- Price format is consistent (e.g., “29.99 USD”)
- Availability uses standard values (in stock, out of stock)
- Variant products include variant-specific data (color, size)
- Feed includes at least title, description, URL, price, availability
- Feed size is under 50MB (for fast parsing)
- Feed updates at least daily
- Feed has a last-modified timestamp
- Feed URL is discoverable (linked from sitemap.xml or robots.txt)
Public accessibility is non-negotiable. Agents cannot authenticate to access feeds. Test feed URLs with curl or a browser to confirm they load without login. If authentication is required for sensitive data, create separate public feeds.
HTTP 200 status indicates the feed loads successfully. 404 errors mean the feed URL is incorrect. 403 errors suggest permissions blocks. 500 errors indicate server-side problems preventing feed generation.
Feed load time affects agent ingestion speed. Slow feeds increase processing time and may cause agent timeouts. Test feed loading with timing tools to ensure feeds load within acceptable timeframes.
Image completeness improves agent understanding. Every product should have at least one image. Broken image URLs (404s) reduce feed quality and agent confidence. Verify image URLs return valid images with HTTP status 200.
Product identifiers like GTIN enable cross-store matching. Agents use GTIN to identify identical products from different sources. Most products should include GTIN, SKU, or MPN in feed data.
Price format consistency prevents parsing errors. Use consistent currency formatting (e.g., “29.99 USD” or “$29.99”). Avoid mixing formats. Agents expect predictable price formatting for accurate comparison.
Availability values use standard terminology. Common values include “in stock”, “out of stock”, “pre-order”, and “backorder”. Avoid custom availability values that agents do not understand.
Variant-specific data enables precise recommendations. Include color, size, material, or other variant attributes in feed data. Agents use this information to match specific user requests.
Feed content includes essential fields. At minimum, feeds should contain title, description, product URL, price, availability, and images. Additional fields like brand, category, and specifications improve matching quality.
Feed size impacts download and processing time. Large feeds take longer to download and parse. Keep feeds under 50MB for optimal performance. Split large catalogs into multiple feeds by category if necessary.
Update frequency keeps feeds current. Daily updates are minimum. Hourly updates are better for fast-moving catalogs. Stale feeds cause agents to recommend unavailable products or incorrect prices.
Last-modified timestamps help agents detect changes. Include a timestamp indicating when the feed was last updated. Agents use this to determine if they need to reprocess the feed.
Discoverable URLs help agents find feeds automatically. Link feed URLs from sitemap.xml or robots.txt. Agent platforms crawl these standard locations to discover available feeds.
FAQ
Does Shopify need a feed app for AI agent discoverability?
Not strictly required for all scenarios, but recommended for automated feeds. Shopify’s native CSV export is manual-only and the GraphQL API requires authentication. Many Shopify stores use third-party apps for automated feed generation.
Can WooCommerce generate feeds without plugins?
No, WooCommerce requires plugins for feed generation. You must install a plugin like Product Feed Manager or WP All Export. Free plugins cover basic needs, but advanced features require paid plugins.
What feed format do AI agents prefer?
AI agents accept XML, JSON, and llms.txt. XML is widely supported, JSON is supported by most modern platforms, and llms.txt has emerging support. The safest approach: generate at least XML and JSON to maximize coverage.
How often should ecommerce feeds update?
Daily minimum for most stores. Hourly for high-velocity catalogs (fashion, flash sales). Real-time updates only necessary for time-sensitive products (tickets, limited inventory).
Do AI agents need feed authentication?
No, agents prefer publicly accessible feeds without authentication. If you require authentication for sensitive data, create a separate public feed with basic product information only.
Sources
- Shopify GraphQL Admin API Documentation. https://shopify.dev/api/admin-graphql
- Google Shopping Feed Requirements. https://support.google.com/merchants/answer/188494
- Schema.org Product Specification. https://schema.org/Product
- WooCommerce REST API Documentation. https://woocommerce.github.io/woocommerce-rest-api-docs/
- Cloudflare Caching Documentation. https://developers.cloudflare.com/cache/
Check your store agent discoverability score free at shopti.ai.