Shopify allergen and dietary schema for AI agents: suitableForDiet, FDA FALCPA 9 vs EU 14 allergens, and cross-contamination encoding

Why allergen structured data is now an AI ranking signal, not just a compliance task

For most of search engine history, allergen information lived in two places: the product ingredient list (required by law) and occasionally the product description (if the merchant remembered to add it). Search engines indexed both as unstructured text, and consumers who searched "gluten-free protein powder" relied on keyword matching against that text plus whatever the merchant put in the title. The result was a system where "gluten-free" in the product title outranked accurate ingredient disclosure — and where a product could rank for "peanut-free" simply because the merchant had written the phrase, not because they had verified it.

AI shopping agents work differently. When a user with a peanut allergy asks ChatGPT Shopping or Perplexity Shopping for "protein bars without peanuts," the agent doesn't return keyword matches — it returns products where the allergen status is verifiable. Products with structured allergen data in their JSON-LD have a decisive advantage: the agent can parse additionalProperty entries for "Peanuts: free-from" directly, without relying on natural language inference from description text. Products without structured allergen data require the agent to make probabilistic inferences from the ingredient list — and agents following conservative safety guidelines will omit products where allergen status is uncertain rather than risk recommending something dangerous to an allergy sufferer.

The shift is amplified by how AI agents handle ambiguity. An AI agent recommending products to an allergy-sensitive user will apply a conservative heuristic: if allergen status cannot be determined from structured data, exclude the product from the recommendation. The cost of a false negative (recommending a product that causes an allergic reaction) is catastrophically higher than the cost of a false positive (excluding a safe product from a recommendation). Merchants who have not structured their allergen data are excluded not because they failed — but because the agent cannot verify that they are safe.

schema.org suitableForDiet: the 11 enum values and when to use each

Schema.org's suitableForDiet property accepts enum values from the RestrictedDiet type. These are the official values — you must use the full URI or the shortened form with "@vocab": "https://schema.org/" as context. Inventing non-standard strings like "glutenFree" or "vegan-certified" causes parsers to ignore the property entirely.

Multiple diet suitability values

suitableForDiet accepts an array — you can and should list all applicable values for a product. A product that is both vegan and gluten-free should have both VeganDiet and GlutenFreeDiet in the array. Do not conflate or choose one: an AI agent building a recommendation for a vegan user with celiac disease needs both signals to correctly include your product.

"suitableForDiet": [
  "https://schema.org/VeganDiet",
  "https://schema.org/GlutenFreeDiet",
  "https://schema.org/KosherDiet"
]

FDA FALCPA 9 vs EU 14 allergens: what each list covers and how to encode both

Regulatory allergen requirements differ by market, and the two most significant frameworks — the US FDA Food Allergen Labeling and Consumer Protection Act (FALCPA, updated by the FASTER Act of 2021, effective January 1, 2023) and the EU Food Information Regulation (FIR 1169/2011, Annex II) — have overlapping but distinct allergen lists. For merchants selling internationally, encoding all 14 EU allergens covers both frameworks.

The key implementation decision for Shopify merchants: encode all 14 EU allergens regardless of your primary market. The cost of adding celery, mustard, lupin, molluscs, and sulphites to your structured data is negligible — five additional metafields and additionalProperty entries. The benefit is a single JSON-LD template that satisfies both the US and EU markets, and coverage for allergy sufferers across all major markets when your products are discovered via AI agents operating globally.

Cross-contamination vs intentional ingredient: the 'may contain' distinction in structured data

The most consequential distinction in allergen structured data is the difference between an intentional ingredient and a cross-contamination risk. These two categories carry different regulatory statuses, different health implications, and must be encoded differently in structured data so that AI agents can present them with appropriate nuance.

The three allergen status values

Every allergen in your structured data should have one of three status values. These are not schema.org-defined enums — they are string values you define within your additionalProperty entries. Consistency across your catalog is what allows AI agents to aggregate and filter reliably.

Why 'may contain' requires its own structured data field

Precautionary allergen labeling (PAL) — the "may contain" or "manufactured on shared equipment with" statements on food labels — is voluntary in the US and not consistently standardized. This makes it particularly important to encode in structured data, because natural language PAL statements are highly variable in wording and severity: "may contain traces of tree nuts," "manufactured in a facility that also processes peanuts," "produced on shared equipment with wheat," and "trace amounts of sesame possible" all convey PAL status but with different implied risk levels.

By encoding cross-contamination risk as a structured additionalProperty with value may-contain, you give AI agents a consistent, parseable signal rather than requiring them to interpret variable natural language. The agent can then present the risk accurately: "This protein powder is peanut-free as an intentional ingredient, but is manufactured on shared equipment with peanuts — the merchant has disclosed a cross-contamination risk."

Encoding cross-contamination for multiple allergens

Many food manufacturing facilities produce multiple products with different allergen profiles. A facility that makes both peanut butter cookies and peanut-free protein bars carries a cross-contamination risk even if the protein bar recipe contains no peanuts. The correct structured data pattern encodes each allergen independently with its specific status for this product — not a blanket "manufactured in a facility with multiple allergens" statement that is too vague to be actionable.

{
  "@type": "PropertyValue",
  "name": "Peanuts",
  "value": "free-from",
  "description": "Not an ingredient. Dedicated peanut-free production line."
},
{
  "@type": "PropertyValue",
  "name": "Tree Nuts",
  "value": "may-contain",
  "description": "Processed in a facility that also handles almonds and cashews."
},
{
  "@type": "PropertyValue",
  "name": "Wheat",
  "value": "contains",
  "description": "Intentional ingredient — see nutrition facts panel."
}

Food safety certifications: GFCO, NSF Gluten-Free, OU Kosher, and hasCertification markup

Third-party certifications are the highest-trust allergen signal in structured data because they carry the authority of an independent testing organization, not just the merchant's self-declaration. Schema.org's hasCertification property (available since schema.org v13.0) allows you to encode certifications with the certifying body, certification name, and optionally a license or certification number.

Why certification outweighs self-declaration for AI agents

An AI agent making recommendations to an allergy-sensitive user has to weigh conflicting signals. A merchant who self-declares "peanut-free" on a product page and a merchant who holds GFCO certification for a gluten-free claim are not equivalent — the GFCO certification was tested and audited, the self-declaration was not. AI agents trained on consumer trust data (reviews, complaints, recall databases) will learn to weight certified claims significantly higher than self-declared claims, especially in categories where incorrect allergen labeling has caused harm.

From a practical standpoint: if your product has third-party certification, encode it. If it does not, use the three-tier allergen status approach above for self-declared status. Do not use hasCertification with a certification name and omit the issuedBy field — an unnamed certification body is treated by AI agents as equivalent to a self-declaration, because there is no authority to verify against.

Complete JSON-LD example: a GFCO-certified gluten-free protein powder

This is a full structured data block for a hypothetical gluten-free whey protein powder that is GFCO certified, has no peanuts as an intentional ingredient (but carries a tree nut cross-contamination advisory), and is suitable for both gluten-free and low-lactose diets. This pattern covers all the elements discussed above.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Alpine Whey Protein — Vanilla Bean 2lb",
  "description": "Cold-processed whey protein concentrate, 24g protein per serving. GFCO certified gluten-free. No artificial sweeteners.",
  "brand": {
    "@type": "Brand",
    "name": "Alpine Nutrition"
  },
  "sku": "ANP-WV-2LB",
  "gtin14": "00012345678905",
  "suitableForDiet": [
    "https://schema.org/GlutenFreeDiet",
    "https://schema.org/LowLactoseDiet"
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "GFCO Gluten-Free Certified",
      "certificationIdentification": "GFCO-2026-AN-4421",
      "issuedBy": {
        "@type": "Organization",
        "name": "Gluten-Free Certification Organization",
        "url": "https://www.gfco.org"
      }
    },
    {
      "@type": "Certification",
      "name": "Non-GMO Project Verified",
      "issuedBy": {
        "@type": "Organization",
        "name": "Non-GMO Project"
      }
    }
  ],
  "additionalProperty": [
    {
      "@type": "PropertyValue",
      "name": "Milk",
      "value": "contains",
      "description": "Whey is a dairy derivative — contains milk proteins."
    },
    {
      "@type": "PropertyValue",
      "name": "Eggs",
      "value": "free-from",
      "description": "No egg ingredients. Verified egg-free facility."
    },
    {
      "@type": "PropertyValue",
      "name": "Wheat",
      "value": "free-from",
      "description": "GFCO certified — tested below 10 ppm gluten."
    },
    {
      "@type": "PropertyValue",
      "name": "Peanuts",
      "value": "free-from",
      "description": "No peanut ingredients. Dedicated peanut-free production area."
    },
    {
      "@type": "PropertyValue",
      "name": "Tree Nuts",
      "value": "may-contain",
      "description": "Manufactured in a facility that also processes almonds and cashews. Dedicated equipment for this product but shared facility."
    },
    {
      "@type": "PropertyValue",
      "name": "Soybeans",
      "value": "free-from",
      "description": "No soy lecithin or soy derivatives. Soy-free verified."
    },
    {
      "@type": "PropertyValue",
      "name": "Sesame",
      "value": "free-from",
      "description": "No sesame ingredients or cross-contamination risk."
    },
    {
      "@type": "PropertyValue",
      "name": "Fish",
      "value": "free-from",
      "description": "No fish ingredients."
    },
    {
      "@type": "PropertyValue",
      "name": "Crustacean Shellfish",
      "value": "free-from",
      "description": "No shellfish ingredients."
    },
    {
      "@type": "PropertyValue",
      "name": "Celery",
      "value": "free-from",
      "description": "No celery or celeriac. EU Annex II compliant."
    },
    {
      "@type": "PropertyValue",
      "name": "Mustard",
      "value": "free-from",
      "description": "No mustard ingredients. EU Annex II compliant."
    },
    {
      "@type": "PropertyValue",
      "name": "Lupin",
      "value": "free-from",
      "description": "No lupin flour or lupin derivatives."
    },
    {
      "@type": "PropertyValue",
      "name": "Molluscs",
      "value": "free-from",
      "description": "No mollusc ingredients."
    },
    {
      "@type": "PropertyValue",
      "name": "Sulphites",
      "value": "free-from",
      "description": "No added sulphur dioxide or sulphites."
    },
    {
      "@type": "PropertyValue",
      "name": "Protein per serving",
      "value": "24",
      "unitCode": "GRM",
      "description": "Per 35g serving"
    }
  ],
  "offers": {
    "@type": "Offer",
    "price": "54.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://alpinenutrition.com/products/whey-vanilla-2lb"
  }
}
</script>

Several elements of this example merit attention. The certificationIdentification field on the GFCO entry is optional but highly recommended — it gives AI agents a verifiable license number that can be cross-referenced against the GFCO public licensee database. The unitCode on nutritional properties uses the UN/CEFACT unit code system (GRM = grams) rather than free text. And every allergen receives its own entry rather than grouping them — this enables allergen-specific filtering by AI agents rather than requiring them to parse a combined allergen statement.

Liquid snippet: allergen metafield → JSON-LD output in Dawn

Managing allergen data through Shopify metafields allows you to update allergen status for any product without editing theme files. The pattern below uses a custom namespace with per-allergen metafields. Each metafield is of type single_line_text_field with allowed values set to contains, free-from, and may-contain via a metafield validation rule.

Step 1: Define metafields in Shopify Admin

Go to Settings → Custom data → Products and create metafields with these keys (all in the custom namespace, type single_line_text_field):

• custom.allergen_milk
• custom.allergen_eggs
• custom.allergen_wheat
• custom.allergen_peanuts
• custom.allergen_tree_nuts
• custom.allergen_soybeans
• custom.allergen_sesame
• custom.allergen_fish
• custom.allergen_shellfish
• custom.allergen_celery
• custom.allergen_mustard
• custom.allergen_lupin
• custom.allergen_molluscs
• custom.allergen_sulphites
• custom.diet_suitable_for (type: list.single_line_text_field — stores schema.org enum values)

Step 2: Liquid template in sections/main-product.liquid

{% comment %} Allergen JSON-LD block — insert before closing </head> tag {% endcomment %}
{% assign allergen_map = "milk:Milk,eggs:Eggs,wheat:Wheat,peanuts:Peanuts,tree_nuts:Tree Nuts,soybeans:Soybeans,sesame:Sesame,fish:Fish,shellfish:Crustacean Shellfish,celery:Celery,mustard:Mustard,lupin:Lupin,molluscs:Molluscs,sulphites:Sulphites" | split: "," %}

{% assign has_allergen_data = false %}
{% for pair in allergen_map %}
  {% assign parts = pair | split: ":" %}
  {% assign key = parts[0] %}
  {% assign metafield_val = product.metafields.custom["allergen_" | append: key].value %}
  {% if metafield_val != blank %}
    {% assign has_allergen_data = true %}
    {% break %}
  {% endif %}
{% endfor %}

{% if has_allergen_data %}
{% assign diet_values = product.metafields.custom.diet_suitable_for.value %}
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": {{ product.title | json }},
  {% if diet_values != blank %}
  "suitableForDiet": [
    {% for diet in diet_values %}
      "https://schema.org/{{ diet }}"{% unless forloop.last %},{% endunless %}
    {% endfor %}
  ],
  {% endif %}
  "additionalProperty": [
    {% assign comma = false %}
    {% for pair in allergen_map %}
      {% assign parts = pair | split: ":" %}
      {% assign key = parts[0] %}
      {% assign label = parts[1] %}
      {% assign val = product.metafields.custom["allergen_" | append: key].value %}
      {% if val != blank %}
        {% if comma %},{% endif %}
        {
          "@type": "PropertyValue",
          "name": {{ label | json }},
          "value": {{ val | json }}
        }
        {% assign comma = true %}
      {% endif %}
    {% endfor %}
  ]
}
</script>
{% endif %}

Allergen metafield reference table

5 common mistakes

FAQ

What is the correct schema.org property for encoding food allergens on a Shopify product page?

Schema.org does not have a dedicated allergenContent property on Product (it exists on NutritionInformation but only accepts a text string). The correct pattern is additionalProperty with @type PropertyValue for each allergen. For dietary suitability categories (gluten-free, vegan, kosher), use suitableForDiet with official RestrictedDiet enum values. The two serve different purposes: suitableForDiet categorizes the product by diet type; allergen additionalProperty entries specify the status of each individual allergen.

What are the 9 major allergens under FDA FALCPA, and how do they differ from the EU's 14 allergens?

FDA FALCPA 9 (updated by the FASTER Act, effective January 1, 2023): milk, eggs, fish, crustacean shellfish, tree nuts, peanuts, wheat, soybeans, sesame. EU Annex II adds 5 more: celery, mustard, lupin, molluscs, and sulphur dioxide/sulphites above 10 mg/kg. For Shopify stores selling internationally, encoding all 14 EU allergens covers both regulatory frameworks with negligible additional effort.

What is the difference between 'free-from', 'contains', and 'may contain' in structured data?

'Contains' means intentional ingredient — the allergen is in the recipe. 'Free-from' means verified absent — not in the formula, manufacturer has confirmed. 'May-contain' is a precautionary advisory for cross-contamination risk — the allergen is not an ingredient but could be present from shared equipment or facility. Encode all three as distinct additionalProperty values so AI agents can distinguish verified absence from cross-contamination risk from intentional presence.

How do I encode a GFCO gluten-free certification in Shopify JSON-LD?

Use hasCertification with @type Certification, name "GFCO Gluten-Free Certified", optional certificationIdentification (your GFCO license number), and issuedBy with the Gluten-Free Certification Organization as an Organization. Always include the issuedBy body — without it, the certification is indistinguishable from a self-declared claim.

Why can't I just put allergen information in the product description text?

Natural language allergen statements are ambiguous and inconsistent — "may contain traces of tree nuts," "processed with nut equipment," and "tree nut cross-contamination possible" all mean the same thing but parse differently. Product descriptions also change during copywriting revisions in ways that structured data does not. Metafield-driven allergen structured data is stable, machine-readable, and updates independently from the product page copy.