Optimization Guide

Shopify Pet Food & Supply Structured Data for AI Shopping Agents

Q: What schema.org type should I use for pet food products in Shopify?

Use the standard Product type for pet food and supplies. Declare pet-specific attributes via 'additionalProperty': use propertyID 'targetAnimal' with values 'Dog', 'Cat', 'Bird', 'Fish', 'Rabbit', 'Hamster', etc. For pet food ingredients and dietary attributes, use 'additionalProperty' with propertyID 'petFoodFeature' for values like 'Grain-Free', 'Limited Ingredient', 'Raw', 'Freeze-Dried', 'Organic', 'High-Protein'. For breed size compatibility, use propertyID 'targetBreedSize' with values 'Small Breed', 'Medium Breed', 'Large Breed', 'All Breeds'.

Q: How do I declare allergen-free claims for pet food in Shopify JSON-LD?

For pet food, use 'additionalProperty' with propertyID 'doesNotContain' to declare absent ingredients that are common pet food sensitivities — for example, 'Chicken', 'Corn', 'Wheat', 'Soy', 'Dairy'. This is distinct from the human allergen 'containsAllergen' pattern. Pet owners frequently search for ingredient exclusions ('cat food with no chicken', 'grain-free turkey dog food') and AI shopping agents need machine-readable ingredient exclusion signals to accurately filter pet food product results.

Q: How do I mark pet life stage (puppy, adult, senior) in Shopify product schema?

Use 'additionalProperty' with propertyID 'targetLifeStage' and values 'Puppy', 'Kitten', 'Adult', 'Senior', 'All Life Stages'. Pair this with 'suggestedAge' using a QuantitativeValue if you want to declare a specific age range (e.g., value: 7, unitCode: 'ANN' for senior dogs aged 7+). Life stage is one of the most common pet food filters in AI shopping queries — 'best puppy food for golden retrievers' is a direct life stage + breed query that requires both signals.

Q: Does Shopify output any pet-specific structured data in its default JSON-LD?

No. Shopify's default product JSON-LD outputs generic Product schema with no pet-specific properties. Target animal, breed size, life stage, protein source, and grain/ingredient-free attributes are only in the product description text or app-generated content — invisible to AI shopping agent crawlers. Pet brands on Shopify must manually add pet-specific additionalProperty signals in product.liquid to surface in AI pet product queries.

Q: How do I mark pet supply compatibility (e.g., harness for specific dog breeds or sizes)?

For pet supplies with size or breed compatibility — harnesses, beds, collars, crates — use 'additionalProperty' with propertyID 'targetAnimal' (Dog/Cat/etc.), 'targetBreedSize' (Small/Medium/Large/Extra-Large), and optionally 'targetWeightRange' with a QuantitativeValue for weight-based sizing (e.g., '10-25 lbs'). For breed-specific items (e.g., a harness designed for brachycephalic breeds), use propertyID 'suitableForBreed' with the breed name. These signals let AI agents match 'large dog harness' or 'flat-faced breed collar' queries.

AI shopping agents answering "grain-free salmon cat food for seniors," "large breed puppy food with no chicken," and "harness for flat-faced dogs" need machine-readable pet-specific signals — not text in product descriptions. Shopify's default JSON-LD has no concept of target animal, breed size, life stage, or ingredient exclusions, making every pet product appear identical to general merchandise.

TL;DR Use additionalProperty to declare targetAnimal (Dog/Cat/Bird), petFoodFeature (Grain-Free/High-Protein/Limited Ingredient), targetLifeStage (Puppy/Adult/Senior), targetBreedSize (Small/Medium/Large Breed), and doesNotContain for absent ingredients. For certified food products, add hasCertification. Store all values in a pet.* metafield namespace with a pet-product tag gate.

The Pet Product Visibility Gap

The pet supplies category generates some of the most structured, filter-rich shopping queries seen in AI agent traffic. Pet owners ask with high specificity: "grain-free salmon dog food for large breeds," "cat food with no chicken or beef — senior formula," "small dog harness for French bulldog," "hypoallergenic cat litter dust-free." These queries carry multiple simultaneous filter requirements (animal type + ingredient constraint + life stage + breed size) that are impossible to satisfy without structured data.

Shopify's default product JSON-LD provides no pet-specific schema. The target animal, protein source, grain-free status, life stage, and breed size compatibility that distinguish one pet food from another are buried in product descriptions as unstructured prose. AI agents reading structured data cannot extract "no chicken" from a description paragraph the way they can read a machine-tagged doesNotContain: Chicken property value.

The schema.org Product type's additionalProperty mechanism, combined with standardized pet-specific propertyIDs, gives pet brands on Shopify the vocabulary to express every filter dimension that AI pet shopping queries require.

Pet product query types requiring structured data

Query type	Example	Required signal	AI shopping behavior
Animal type + formula	"grain-free dog food"	`targetAnimal: Dog` + `petFoodFeature: Grain-Free`	Filters to dog products with grain-free dietary attribute
Ingredient exclusion	"cat food with no chicken"	`doesNotContain: Chicken` on a cat product	Excludes cat food products that contain chicken as an ingredient
Life stage filter	"senior dog food for large breeds"	`targetLifeStage: Senior` + `targetBreedSize: Large Breed`	Surfaces senior-formula food formulated for large breed dogs
Supply compatibility	"medium dog harness for pullers"	`targetAnimal: Dog` + `targetBreedSize: Medium Breed`	Matches dog harnesses sized for medium breeds
Certification filter	"USDA Organic cat food"	`hasCertification: USDA Organic`	Surfaces pet food with verified organic certification

Shopify default vs. pet-aware JSON-LD

Shopify default (no pet signals)

{
  "@type": "Product",
  "name": "Salmon & Pea Grain-Free
    Adult Dog Food",
  "description": "Grain-free salmon
    formula. No chicken or corn.
    Ideal for large breeds.",
  // all signals buried in text
  // invisible to AI filters
}

With pet-specific schema

"additionalProperty": [
  { "propertyID": "targetAnimal",
    "value": "Dog" },
  { "propertyID": "petFoodFeature",
    "value": "Grain-Free" },
  { "propertyID": "targetLifeStage",
    "value": "Adult" },
  { "propertyID": "targetBreedSize",
    "value": "Large Breed" },
  { "propertyID": "doesNotContain",
    "value": "Chicken" }
]

Pet Product JSON-LD Patterns

Pet food — grain-free with ingredient exclusion

Baseline pattern for a pet food product with dietary feature, target animal, life stage, breed size, and ingredient exclusion declarations. This combination addresses the majority of AI pet food filter query types:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Wild Salmon & Pea Adult Dog Food — Large Breed",
  "description": "Grain-free salmon and pea recipe for large breed adult dogs. No chicken, corn, wheat, or soy.",
  "brand": { "@type": "Brand", "name": "PureWild" },
  "additionalProperty": [
    {
      "@type": "PropertyValue",
      "propertyID": "targetAnimal",
      "name": "Target animal",
      "value": "Dog"
    },
    {
      "@type": "PropertyValue",
      "propertyID": "petFoodFeature",
      "name": "Pet food feature",
      "value": "Grain-Free"
    },
    {
      "@type": "PropertyValue",
      "propertyID": "primaryProtein",
      "name": "Primary protein source",
      "value": "Salmon"
    },
    {
      "@type": "PropertyValue",
      "propertyID": "targetLifeStage",
      "name": "Life stage",
      "value": "Adult"
    },
    {
      "@type": "PropertyValue",
      "propertyID": "targetBreedSize",
      "name": "Breed size",
      "value": "Large Breed"
    },
    {
      "@type": "PropertyValue",
      "propertyID": "doesNotContain",
      "name": "Does not contain",
      "value": "Chicken"
    },
    {
      "@type": "PropertyValue",
      "propertyID": "doesNotContain",
      "name": "Does not contain",
      "value": "Corn"
    },
    {
      "@type": "PropertyValue",
      "propertyID": "doesNotContain",
      "name": "Does not contain",
      "value": "Wheat"
    }
  ],
  "offers": {
    "@type": "Offer",
    "price": "64.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}

Multiple life stages — puppy, adult, senior variants

For brands selling the same formula across life stages as separate SKUs, use ProductGroup with hasVariant. Each variant carries its own targetLifeStage and optionally suggestedAge QuantitativeValue for age-range precision:

{
  "@context": "https://schema.org",
  "@type": "ProductGroup",
  "name": "Pacific Salmon Dog Food — All Life Stages",
  "hasVariant": [
    {
      "@type": "Product",
      "name": "Pacific Salmon Dog Food — Puppy",
      "sku": "PSF-PUPPY",
      "additionalProperty": [
        { "@type": "PropertyValue", "propertyID": "targetAnimal", "value": "Dog" },
        { "@type": "PropertyValue", "propertyID": "targetLifeStage", "value": "Puppy" },
        {
          "@type": "PropertyValue",
          "propertyID": "suggestedAgeMax",
          "name": "Suitable up to age",
          "value": {
            "@type": "QuantitativeValue",
            "value": 12,
            "unitCode": "MON"
          }
        }
      ],
      "offers": { "@type": "Offer", "price": "54.99", "priceCurrency": "USD", "availability": "https://schema.org/InStock" }
    },
    {
      "@type": "Product",
      "name": "Pacific Salmon Dog Food — Adult",
      "sku": "PSF-ADULT",
      "additionalProperty": [
        { "@type": "PropertyValue", "propertyID": "targetAnimal", "value": "Dog" },
        { "@type": "PropertyValue", "propertyID": "targetLifeStage", "value": "Adult" }
      ],
      "offers": { "@type": "Offer", "price": "64.99", "priceCurrency": "USD", "availability": "https://schema.org/InStock" }
    },
    {
      "@type": "Product",
      "name": "Pacific Salmon Dog Food — Senior",
      "sku": "PSF-SENIOR",
      "additionalProperty": [
        { "@type": "PropertyValue", "propertyID": "targetAnimal", "value": "Dog" },
        { "@type": "PropertyValue", "propertyID": "targetLifeStage", "value": "Senior" },
        {
          "@type": "PropertyValue",
          "propertyID": "suggestedAgeMin",
          "name": "Suitable from age",
          "value": {
            "@type": "QuantitativeValue",
            "value": 7,
            "unitCode": "ANN"
          }
        }
      ],
      "offers": { "@type": "Offer", "price": "69.99", "priceCurrency": "USD", "availability": "https://schema.org/InStock" }
    }
  ]
}

Pet supply with breed size and weight compatibility

For pet accessories and supplies with size compatibility — harnesses, beds, collars, crates — declare target animal, breed size category, and weight range. For breed-specific products, use suitableForBreed:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "No-Pull Dog Harness — Medium",
  "description": "Front-clip no-pull harness for medium dogs. Padded chest plate. Fits chest 18-24 inches.",
  "additionalProperty": [
    {
      "@type": "PropertyValue",
      "propertyID": "targetAnimal",
      "name": "Target animal",
      "value": "Dog"
    },
    {
      "@type": "PropertyValue",
      "propertyID": "targetBreedSize",
      "name": "Breed size",
      "value": "Medium Breed"
    },
    {
      "@type": "PropertyValue",
      "propertyID": "targetWeightRange",
      "name": "Target weight range",
      "value": {
        "@type": "QuantitativeValue",
        "minValue": 25,
        "maxValue": 60,
        "unitCode": "LBR"
      }
    },
    {
      "@type": "PropertyValue",
      "propertyID": "petProductFeature",
      "name": "Product feature",
      "value": "No-Pull"
    }
  ],
  "offers": {
    "@type": "Offer",
    "price": "34.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}

Shopify Liquid implementation with metafields

Store pet attributes in a pet metafield namespace. Gate on product tag to avoid injecting pet schema on non-pet products in mixed catalogs:

{% if product.tags contains 'pet-product' %}
{% assign pet = product.metafields.pet %}

{% endif %}

Pet product attribute reference

propertyID	Example values	Query type unlocked
`targetAnimal`	Dog, Cat, Bird, Fish, Rabbit, Hamster, Horse	"grain-free cat food", "dog bed for large breeds"
`petFoodFeature`	Grain-Free, Limited Ingredient, Raw, Freeze-Dried, High-Protein, Organic, Hypoallergenic	"grain-free salmon dog food", "high-protein cat food"
`primaryProtein`	Chicken, Salmon, Beef, Turkey, Duck, Lamb, Venison, Pork	"salmon-based dog food", "duck formula cat food"
`targetLifeStage`	Puppy, Kitten, Adult, Senior, All Life Stages	"senior cat food", "puppy food for large breeds"
`targetBreedSize`	Small Breed, Medium Breed, Large Breed, Extra-Large Breed, All Breeds	"large breed dog food", "small dog harness"
`doesNotContain`	Chicken, Corn, Wheat, Soy, Dairy, Grains, Artificial Preservatives	"cat food with no chicken", "grain-free no soy dog food"

Common Mistakes

1. Relying on product title and description for all pet filter signals

"Grain-Free Salmon & Pea Large Breed Adult Dog Food" is an excellent human-readable product title. It is useless for structured AI filtering because "grain-free," "large breed," "adult," and "salmon" are unstructured text tokens — not machine-readable property declarations. AI agents filter product catalogs using structured data fields, not natural language parsing of product titles across thousands of products simultaneously.

2. Using generic "Allergen-free" instead of specific ingredient exclusions

Declaring a single additionalProperty: allergenFree: true is not actionable for AI agents answering "cat food with no chicken." AI agents need specific ingredient exclusion declarations — doesNotContain: Chicken, doesNotContain: Corn, etc. — to accurately match the specific ingredient a pet owner needs to avoid. Broad "allergen-free" claims cannot be matched to specific ingredient queries.

3. Inconsistent target animal values across products

Using "Dog", "dogs", "Canine", and "K9" interchangeably across products for the same target animal makes AI agent filtering unreliable. A query for "dog food" matching targetAnimal: Dog will miss products tagged targetAnimal: Canine. Standardize animal names across your catalog — use the canonical: Dog, Cat, Bird, Fish, Rabbit, Hamster, Horse, Guinea Pig.

4. Missing life stage on pet food products

Life stage is the second most important pet food filter after target animal. "Puppy," "Adult," and "Senior" formulas have distinct nutritional profiles — DHA levels, calcium ratios, caloric density. AI agents answering "puppy food for golden retrievers" will not surface an adult formula labeled "All Life Stages" unless you also declare targetLifeStage: Puppy. If your product is formulated for all life stages, declare that explicitly as targetLifeStage: All Life Stages.

5. No tag gate — injecting pet schema on non-pet products

Pet supply brands selling both pet products and human products (grooming brands, outdoor brands with pet and human lines) must gate pet-specific additionalProperty injection on a tag. Injecting targetAnimal: Dog on a human shampoo or human backpack corrupts the product's structured data signal and can cause the product to appear in pet queries while being excluded from general human-product queries.

Implementation Checklist

Declare targetAnimal additionalProperty for every pet product (Dog/Cat/Bird/etc.)
Declare petFoodFeature for each dietary attribute (Grain-Free, High-Protein, Limited Ingredient, Raw)
Declare primaryProtein for pet food with a named protein source
Declare targetLifeStage for pet food products (Puppy/Kitten/Adult/Senior/All Life Stages)
Declare targetBreedSize for breed-size-specific products (Small/Medium/Large/Extra-Large Breed)
Declare doesNotContain for each absent ingredient relevant to pet food sensitivities
Use hasCertification for USDA Organic, NASC Quality Seal, or other third-party pet food certifications
Store all pet attributes in a pet.* metafield namespace for Liquid injection
Gate pet JSON-LD injection on a product tag (e.g., pet-product) in mixed catalogs

Frequently Asked Questions

What schema.org type should I use for pet food products in Shopify?

Use the standard Product type. Declare pet-specific attributes via additionalProperty: targetAnimal (Dog/Cat/Bird), petFoodFeature (Grain-Free/High-Protein/Raw/Freeze-Dried), targetLifeStage (Puppy/Adult/Senior), and targetBreedSize (Small/Medium/Large Breed). Pair with doesNotContain for ingredient exclusions and hasCertification for verified certifications.

How do I declare allergen-free claims for pet food in Shopify JSON-LD?

Use additionalProperty with propertyID: "doesNotContain" for each specifically absent ingredient — one PropertyValue per ingredient (Chicken, Corn, Wheat, Soy, Dairy). This is distinct from the human food containsAllergen pattern. Declare each ingredient exclusion separately so AI agents can match single-ingredient queries like "cat food with no chicken" independently from multi-ingredient exclusion queries.

How do I mark pet life stage (puppy, adult, senior) in Shopify product schema?

Use additionalProperty: targetLifeStage with values Puppy, Kitten, Adult, Senior, or All Life Stages. For precise age ranges, add suggestedAgeMin or suggestedAgeMax additionalProperty with a QuantitativeValue (e.g., value: 7, unitCode: ANN for senior dogs 7+). Life stage is the second most common pet food filter in AI shopping queries after target animal.

Does Shopify output any pet-specific structured data in its default JSON-LD?

No. Shopify's default JSON-LD outputs generic Product schema with no pet-specific properties. Target animal, breed size, life stage, protein source, and grain-free attributes are only in description text — invisible to AI crawlers. Pet brands must manually add additionalProperty pet signals in product.liquid.

How do I mark pet supply compatibility (e.g., harness for specific dog breeds or sizes)?

Use additionalProperty with targetAnimal, targetBreedSize (Small/Medium/Large/Extra-Large Breed), and targetWeightRange (QuantitativeValue with minValue/maxValue in LBR or KGM unitCode). For breed-specific items, add suitableForBreed with the breed name. These signals let AI agents match queries like "large dog crate" or "harness for brachycephalic breeds."