Validating Structured Data for Search

You’ve added structured data to your pages. But is it actually working? Invalid markup—missing properties, syntax errors, wrong types—gets ignored by search engines. Your FAQ won’t get dropdowns. Your products won’t show prices and ratings.

Validation catches these issues before they cost you rich results.

Why Validation Matters

Structured data can fail silently. Unlike JavaScript errors that break functionality, invalid JSON-LD just… doesn’t work. Search engines skip it without notification.

Common failure modes:

• Syntax errors: Broken JSON that doesn’t parse
• Missing required properties: Schema types need specific fields
• Wrong data types: String where number expected
• Outdated schemas: Using deprecated properties
• Logic errors: Valid syntax but incorrect usage

Types of Errors

Syntax Errors

JSON must be valid before schema.org matters:

// Missing comma - won't parse
{
  "name": "Product"
  "price": 99.99
}

// Trailing comma - won't parse
{
  "name": "Product",
  "price": 99.99,
}

// Single quotes - won't parse
{
  'name': 'Product'
}

These break completely—no structured data is recognized.

Missing Required Properties

Each schema type has required properties for rich results:

Product requires:

• name
• offers (with price and priceCurrency)

FAQPage requires:

• mainEntity (array of Question objects)

Recipe requires:

• name
• image

Without required properties, Google won’t display rich results.

Wrong Property Types

Properties expect specific data types:

// Wrong - price should be a number or string
"price": {
  "amount": 99.99
}

// Correct
"price": "99.99"

Invalid URLs

URL properties must be valid:

// Invalid
"url": "example.com/page"

// Valid
"url": "https://example.com/page"

Deprecated Properties

Schema.org evolves. Some properties are deprecated:

// Deprecated
"aggregateRating": {
  "ratingCount": 50
}

// Current
"aggregateRating": {
  "reviewCount": 50
}

Validation Tools

Google Rich Results Test

Google’s official tool for testing rich result eligibility:

• Checks if markup is detected
• Shows which rich results are eligible
• Identifies errors and warnings
• Renders mobile and desktop

Limitations:

• Only tests one URL at a time
• Must be publicly accessible
• Focuses on Google-specific requirements

Schema.org Validator

Validates against the schema.org specification:

• More comprehensive than Google’s tool
• Catches issues Google might not surface
• Useful for non-Google use cases

Our Schema Validator

The Schema Validator provides:

• All structured data found on the page
• Schema type identification
• Property completeness check
• Error and warning messages
• Recommendations for improvement

It’s free and works on any URL—useful for quick checks without switching between tools.

In-Browser Testing

During development, validate JSON syntax:

try {
  JSON.parse(yourJsonLd);
  console.log('Valid JSON');
} catch (e) {
  console.error('Invalid JSON:', e.message);
}

Common Issues by Schema Type

Article / BlogPosting

Common errors:

• Missing author (should be Person or Organization)
• Missing datePublished
• image as string instead of ImageObject or array

Correct structure:

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Article Title",
  "image": ["https://example.com/image.jpg"],
  "datePublished": "2026-04-06",
  "author": {
    "@type": "Organization",
    "name": "Company Name"
  }
}

Product

Common errors:

• Missing offers
• price without priceCurrency
• availability using custom strings instead of schema.org URLs

Correct structure:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Product Name",
  "offers": {
    "@type": "Offer",
    "price": "99.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}

FAQPage

Common errors:

• Questions not wrapped in mainEntity
• Missing acceptedAnswer within questions
• text property missing from answers

Correct structure:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is the question?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "This is the answer."
      }
    }
  ]
}

LocalBusiness

Common errors:

• Missing address
• address as string instead of PostalAddress object
• Missing or malformed openingHours

Correct structure:

{
  "@context": "https://schema.org",
  "@type": "LocalBusiness",
  "name": "Business Name",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "123 Main St",
    "addressLocality": "City",
    "addressRegion": "State",
    "postalCode": "12345"
  }
}

Validation Workflow

During Development

1. Write structured data
2. Validate JSON syntax
3. Test with Schema Validator
4. Fix any errors
5. Test with Google Rich Results Test
6. Deploy

After Deployment

1. Monitor Search Console for structured data errors
2. Re-validate after content changes
3. Check competitor pages for schema ideas
4. Update schemas when Google requirements change

Regular Audits

1. Crawl site to extract all structured data
2. Batch validate
3. Prioritize fixes by page importance
4. Track eligible vs. actual rich results

Debugging Tips

View Source vs Rendered HTML

Some structured data is injected by JavaScript. Use:

• “View Page Source” for static HTML
• DevTools → Sources for JavaScript-injected
• Rich Results Test renders JavaScript

Check for Multiple Schemas

Pages can have multiple JSON-LD blocks. Ensure:

• No conflicts between them
• All are valid independently
• They complement rather than contradict

Test Production, Not Just Development

Development environments may:

• Use different URLs
• Missing assets
• Have placeholder content

Validate the production URL.

Warnings vs Errors

Errors

Must be fixed. Rich results won’t appear.

Example: Missing required property

Warnings

Should be fixed. Rich results may appear but won’t be optimal.

Example: Recommended property missing

Best Practices

No effect on eligibility, but improve quality.

Example: Image resolution recommendations

Prioritize errors, then warnings, then best practices.

Schema Generation vs Validation

Generation

Create structured data from scratch:

• Use our Schema Generator for common types
• Ensures correct structure from the start
• Reduces validation issues

Validation

Check existing structured data:

• Find issues after implementation
• Verify third-party implementations
• Audit site-wide

Both are valuable at different stages.

Staying Current

Structured data requirements change:

• Google updates rich result requirements
• schema.org releases new versions
• New rich result types appear

Monitor:

• Google Search Central blog
• Google Search Console warnings
• Periodic re-validation of key pages

Take Action

1. Validate your key pages with Schema Validator
2. Fix any errors
3. Use Schema Generator for missing schemas
4. Test with Google Rich Results Test
5. Monitor Search Console for ongoing issues

For help with structured data implementation or SEO strategy, reach out.