Skip to content
QAIL
Book a Demo Get Started
Agentic Commerce & AI Agents

Structured Data for AI Agents: The Schema.org Properties That Get You Recommended (or Skipped)

QAIL AI Team 8 min read

When a human lands on your product page, they see photography, layout, and social proof. When an AI shopping agent visits, it reads markup. The gap between what resonates with a human and what parses cleanly for an agent is now a commercial gap — because AI-driven product recommendations and autonomous purchases are no longer a future scenario.

AI assistants handling shopping requests, task agents comparing service providers, and recommendation engines embedded in every major platform are all making the same calculation: whose data is complete enough to trust? If the answer isn’t yours, they move on. They don’t ask for clarification. They don’t click to the next page. They just skip you.

This post covers which structured data properties determine agent selection, why JSON-LD has become the de facto standard, and how to audit what you have before an agent makes that decision for you.

Why Agents Rely on Structured Data More Than Prose

The problem with most product pages is that they were written for two audiences: search engine crawlers and human readers. Structured data was added to serve the first group — rich snippets, product carousels, star ratings in search results. Marketing copy was written to persuade the second. Both formats leave AI agents working too hard.

A product description written as marketing prose (“Experience the unparalleled comfort of our premium organic cotton”) tells an agent almost nothing useful. It can’t extract material composition, thread count, certifications, or price from that sentence without significant inference — and inference introduces errors. When an agent is trying to answer “find a certified organic cotton hoodie under $60 with free shipping,” every attribute it has to infer is an attribute it might get wrong, and a wrong inference means your product gets excluded from a result set it should be in.

Structured data solves this by making attributes machine-readable without requiring inference. When your page includes a JSON-LD block that explicitly declares material: "100% organic cotton", price: 54.00, and shippingDetails pointing to a free shipping policy, the agent knows. Not infers — knows. That certainty is what gets you into consideration sets.

This is why the agentic web is pushing structured data from a nice-to-have to a hard requirement. The shift happening now mirrors what happened with mobile optimization in 2015 and HTTPS in 2018: a property that was previously optional becomes a baseline, and sites that haven’t kept up stop appearing in contexts that matter.

The Schema.org Types That Actually Matter

Schema.org defines hundreds of types, but for most businesses operating in 2026, the ones that determine agentic visibility reduce to a handful.

Product and Offer

For any page selling a physical or digital product, schema:Product with a nested schema:Offer is the foundation. The properties that agents actually use to match buyer intent include:

  • name — the product name as a human would search for it, not your internal SKU label
  • description — factual, attribute-dense prose (minimum 150 characters); this is the one place where text matters more than brevity
  • image — at least one image URL; agents don’t render images, but they confirm images exist as a quality signal
  • brand — a nested Brand object with name, not just a string
  • sku and gtin (GTIN-12, GTIN-13, or GTIN-14) — unambiguous product identifiers that allow cross-referencing across sources
  • offers.price and offers.priceCurrency — explicit values, not injected dynamically in a way that doesn’t appear in the static markup
  • offers.availability — from the valid enumeration: InStock, OutOfStock, PreOrder; agents filter by this in real time
  • offers.priceValidUntil — a date confirming the price hasn’t expired; missing this signals stale data
  • offers.shippingDetails — a OfferShippingDetails object with shippingRate and deliveryTime
  • offers.hasMerchantReturnPolicy — agents handling purchases on behalf of users increasingly factor return policy into selection

The GTIN is worth dwelling on. Agents comparing products across multiple merchants use it to match identical items and then sort by price, availability, and trust signals. If your product has a GTIN and you don’t include it, you’re invisible to that comparison. If your product doesn’t have a GTIN (custom or private-label goods), use mpn (manufacturer part number) and brand together to establish unambiguous identity.

AggregateRating and Review

Trust signals aren’t just for humans. Agents making purchase recommendations on behalf of users are increasingly instructed to consider review quality and recency. The AggregateRating type — with ratingValue, reviewCount, and bestRating — is parseable at a glance. Individual Review objects with datePublished allow agents to assess recency.

The key failure mode here is leaving review data in JavaScript-rendered DOM that only appears after a user interaction. If your star ratings only materialize after a scroll or tab click, the markup isn’t available to most agents. Test with a view-source check, not a browser rendering.

Organization and LocalBusiness

For service businesses, B2B, and SaaS, schema:Organization on the homepage and key landing pages signals entity-level trust. Properties that matter include name, url, logo, foundingDate, numberOfEmployees (even a range), sameAs links to your LinkedIn and Crunchbase profiles, and — critically — contactPoint with contactType.

The sameAs array is how knowledge graph disambiguation works. When an agent encounters “QAIL” as a company name, the sameAs links pointing to authoritative external sources confirm which QAIL is being referenced. Without them, a name collision with another entity can cause your brand to be excluded from responses where you should appear.

Service and SoftwareApplication

SaaS companies have a distinct challenge: there’s no GTIN equivalent for software. The schema:SoftwareApplication type (for software) and schema:Service (for services) fill this gap. Key properties include applicationCategory, operatingSystem, offers (with pricing), and — for services — serviceType, areaServed, and provider.

These types are underimplemented. A quick crawl of mid-market SaaS sites shows that most have no structured data on pricing pages beyond generic WebPage markup. This is a meaningful gap: an agent trying to compare SaaS vendors on price, features, or support model is working from inference on every site that hasn’t marked this up explicitly.

The Mistakes That Get You Skipped

The most common structured data failure isn’t missing fields — it’s fields that exist but contain stale or invalid values. Agents that encounter availability marked InStock for a product that returns a 404 on the product URL learn to distrust your markup. The same applies to prices that don’t match what’s displayed in the page’s visible text, or priceValidUntil dates from 2024.

Five patterns that cause agents to skip or deprioritize your listings:

  1. Availability mismatch. Your JSON-LD says InStock; the page says “Currently unavailable.” An agent making a purchase cannot proceed, and a recommendation engine learns not to surface you for availability-sensitive queries.
  2. Dynamic pricing in static markup. If your actual price is rendered by JavaScript but your JSON-LD block shows a hardcoded placeholder, the structured data is wrong. Agents that validate markup against visible content will deprioritize you.
  3. Missing GTINs on trackable products. If your product exists in a product catalog database (almost everything sold through a distributor does), omitting the GTIN makes you invisible to cross-merchant comparisons.
  4. Review markup without dates. AggregateRating with no dateModified, and individual reviews with no datePublished, cannot be assessed for recency. Agents handling high-consideration purchases are increasingly filtering for recent review activity.
  5. Duplicate JSON-LD blocks with conflicting values. Multiple structured data blocks on the same page declaring different prices or availability values create ambiguity that agents resolve by exclusion.

Beyond Products: What Service and B2B Sites Should Mark Up

The conversation about structured data for agents has focused heavily on ecommerce, but agentic commerce encompasses services, SaaS, and B2B relationships as well. When an agent is helping a user find a lead verification vendor, an analytics platform, or a managed service provider, it’s conducting the same evaluation — just without GTINs.

For B2B and SaaS sites, the structured data gap is usually worst on three page types:

  • Pricing pages — often built with dynamic components that emit no parseable structured data; a static SoftwareApplication or Service block with offers entries fixes this
  • Integration or features pages — critical for agent evaluation of platform fit; itemListElement with ListItem objects makes feature lists parseable
  • Case study and results pages — Article or ItemPage markup with about pointing to a Thing (the problem solved) and datePublished for recency

The MCP endpoints post covers the protocol layer for AI-ready commerce; structured data is the complementary layer below it. An MCP endpoint makes your capabilities programmatically accessible to agents that know how to use MCP. Structured data makes your basic attributes legible to every agent, regardless of protocol sophistication.

How to Audit What You Have

Three checks you can run today:

1. Google’s Rich Results Test. Paste any URL at search.google.com/test/rich-results. It renders JavaScript, shows you which schema types were detected, and flags errors or warnings. This is the most complete single-URL check available.

2. View-source spot check. Open your most important product or service page, view source (Ctrl+U), and search for application/ld+json. If the string doesn’t appear, you have no JSON-LD at all. If it does appear, visually scan the block for obvious problems: null values, empty strings, prices that don’t match what the page displays.

3. Cross-reference against visible content. Pick five product pages at random and compare the structured data price and availability to what’s displayed. Any mismatch is a signal quality problem that agents will penalize.

The agent-ready website checklist covers structured data as one of ten categories — but structured data is the category with the highest density of fixable problems on most sites. It’s also the one where the fix is a JSON block in a page template, not a platform migration.

For a site-wide picture of how AI agents are currently perceiving and interacting with your property, the baseline is understanding what they see when they arrive. Our analysis of 30M+ visits shows that AI crawlers are now a substantial fraction of all site traffic — and they’re evaluating your structured data on every request.

What to Prioritize

If you’re triaging a backlog of structured data work, the sequence that delivers the most agent-visibility improvement per hour of work:

  1. Add or fix Product + Offer markup on your highest-traffic product pages. Price, availability, GTIN, and shipping details first; everything else second.
  2. Add AggregateRating with dateModified. If you have reviews, mark them up with dates.
  3. Add Organization markup on your homepage. Include sameAs links to at least two authoritative external profiles.
  4. Fix any availability or price mismatches. Stale data actively harms you; it’s worse than no data.
  5. Mark up your pricing page. Use SoftwareApplication or Service + Offer if you’re SaaS or a service business.

None of this requires a platform change. JSON-LD blocks can be added to page templates without touching your product database or CMS data model. The work is template-level, not infrastructure-level — which is why the gap between sites that have done this and sites that haven’t is surprising given how much is at stake.

The agents making recommendations and purchases on behalf of users are reading structured data right now. The question is whether yours says what you want it to say — or whether it says nothing at all.

Run your free Agent Readiness Score to see how your structured data compares against the signals AI agents actually evaluate. The audit covers structured data quality alongside the nine other factors that determine whether agents select your site or move on.