JSON-LD Validator

Validate JSON-LD structured data on web pages and check for common errors.

What does JSON-LD Validator do?

This actor validates JSON-LD structured data on web pages. It extracts all <script type="application/ld+json"> blocks, validates JSON syntax, checks for required properties (@context, @type), and verifies recommended fields for known Schema.org types like Product, Article, Organization, and more. Use it to catch structured data errors before they cost you rich snippets in search results.

Use cases

• SEO specialists -- validate structured data across hundreds of pages to ensure rich snippet eligibility in Google Search
• Web developers -- catch JSON-LD syntax errors and missing required fields before deploying to production
• Schema.org compliance auditors -- verify that all required and recommended properties are present for each Schema.org type
• Competitive analysts -- examine what structured data competitors implement and compare quality with your own pages
• QA teams -- include JSON-LD validation as part of your pre-release testing pipeline

Why use JSON-LD Validator?

• Syntax validation -- detects malformed JSON that would silently break rich snippets in search engines
• Required field checks -- verifies that @context, @type, and type-specific required properties are present
• Recommended field warnings -- flags missing recommended fields for known Schema.org types so you can maximize rich result coverage
• Batch processing -- validate hundreds of URLs in a single run instead of testing pages one at a time
• Detailed error reports -- each JSON-LD block gets individual errors and warnings with clear descriptions
• Pay-per-event pricing -- only pay for each URL validated, no monthly subscription required

Input parameters

Parameter	Type	Required	Default	Description
urls	string[]	Yes	--	List of URLs to validate JSON-LD for

Example input

{
    "urls": [
        "https://www.google.com",
        "https://www.wikipedia.org",
        "https://example.com"
    ]
}

Output example

{
    "url": "https://www.google.com",
    "jsonLdCount": 1,
    "isValid": true,
    "errorCount": 0,
    "warningCount": 0,
    "types": ["WebSite"],
    "blocks": [
        {
            "index": 0,
            "isValidJson": true,
            "type": "WebSite",
            "context": "https://schema.org",
            "errors": [],
            "warnings": []
        }
    ],
    "error": null,
    "checkedAt": "2026-03-01T12:00:00.000Z"
}

Output fields

Field	Type	Description
url	string	The validated page URL
jsonLdCount	number	Number of JSON-LD blocks found on the page
isValid	boolean	Whether all JSON-LD blocks passed validation
errorCount	number	Total number of errors across all blocks
warningCount	number	Total number of warnings across all blocks
types	string[]	List of Schema.org types found in JSON-LD blocks
blocks	array	Per-block validation details with index, type, context, errors, and warnings
error	string	Error message if the page could not be fetched, null otherwise
checkedAt	string	ISO timestamp of the validation

How much does it cost to validate JSON-LD structured data?

JSON-LD Validator uses Apify's pay-per-event pricing model. You only pay for what you use.

Event	Price	Description
Start	$0.035	One-time per run
URL validated	$0.001	Per URL validated

Example costs:

• 10 pages: $0.035 + 10 x $0.001 = $0.045
• 100 pages: $0.035 + 100 x $0.001 = $0.135
• 1,000 pages: $0.035 + 1,000 x $0.001 = $1.035

How to validate JSON-LD on web pages

1. Go to the JSON-LD Validator page on Apify Store.
2. Click Try for free to open the actor configuration.
3. Add the URLs of the pages you want to validate.
4. Click Start and wait for the run to finish.
5. Review the results — each page shows JSON-LD block count, Schema.org types, errors, and warnings.
6. Download your data as JSON, CSV, or Excel, or connect via the Apify API.

Using the Apify API

You can start JSON-LD Validator programmatically from your own applications using the Apify API. The following examples show how to run the actor and retrieve results in both Node.js and Python.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('automation-lab/jsonld-validator').call({
    urls: ['https://www.google.com'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('automation-lab/jsonld-validator').call(run_input={
    'urls': ['https://www.google.com'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

cURL

curl "https://api.apify.com/v2/acts/automation-lab~jsonld-validator/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{"urls": ["https://www.google.com"]}'

Use with AI agents via MCP

JSON-LD Validator is available as a tool for AI assistants via the Model Context Protocol (MCP).

Setup for Claude Code

$claude mcp add --transport http apify "https://mcp.apify.com"

Setup for Claude Desktop, Cursor, or VS Code

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}

Example prompts

• "Validate JSON-LD structured data on this page"
• "Check schema markup for these product pages"

Learn more in the Apify MCP documentation.

Integrations

JSON-LD Validator works with all major automation platforms available on Apify. Export results to Google Sheets to build a validation dashboard that tracks errors across your site over time. Use Zapier or Make to trigger validation after every deployment. Send alerts to Slack when new JSON-LD errors are detected on critical pages. Pipe results into n8n workflows for custom processing, or set up webhooks to get notified as soon as a validation run finishes. Chain it with Structured Data Extractor to first extract all markup and then validate the JSON-LD blocks.

Tips and best practices

• Prioritize pages with rich snippet potential -- focus on product pages, articles, recipes, and FAQ pages where valid JSON-LD directly impacts search visibility
• Fix errors before warnings -- errors (like invalid JSON or missing @type) prevent rich snippets entirely, while warnings about missing recommended fields only reduce their quality
• Filter results by isValid: false to quickly find all pages that need attention
• Run after every deployment -- add JSON-LD validation to your CI/CD pipeline to catch regressions before they reach production
• Combine with Structured Data Extractor -- use that actor to get a full picture of all markup formats (JSON-LD, Microdata, RDFa), then run this validator on the JSON-LD blocks specifically

Legality

This tool analyzes publicly accessible web content. Automated analysis of public web resources is standard practice in SEO and web development. Always respect robots.txt directives and rate limits when analyzing third-party websites. For personal data processing, ensure compliance with applicable privacy regulations.

FAQ

What Schema.org types does it validate? The actor checks required and recommended fields for common types including Product, Article, Organization, WebSite, BreadcrumbList, FAQPage, Recipe, Event, LocalBusiness, and more.

Does it validate Microdata or RDFa? No. This actor focuses exclusively on JSON-LD blocks (<script type="application/ld+json">). For extracting all three structured data formats, use the Structured Data Extractor actor.

What counts as an error vs. a warning? Errors are issues that make the JSON-LD invalid or unusable, such as malformed JSON syntax or missing @context/@type. Warnings indicate missing recommended properties that could improve rich snippet eligibility but are not strictly required.

The page has JSON-LD but the actor reports jsonLdCount: 0. Why? The actor extracts JSON-LD from <script type="application/ld+json"> tags in the HTML source. If your JSON-LD is injected by client-side JavaScript after page load, it will not be found because the actor uses HTTP requests without a browser. Most CMS platforms and frameworks server-render JSON-LD, but single-page applications may inject it dynamically.

How is this different from Google's Rich Results Test? Google's Rich Results Test checks one URL at a time in a browser and focuses on Google-specific rich result eligibility. This actor validates JSON-LD syntax and Schema.org compliance in bulk across hundreds of URLs using HTTP requests, making it faster and more scalable for site-wide audits.

Other SEO tools

• Internal Link Analyzer — Analyze internal and external link structure on web pages
• Keyword Density Analyzer — Analyze keyword frequency and density on web pages
• Broken Link Checker — Find broken links across your website
• SEO Title Checker — Check title tags for SEO best practices
• Heading Structure Checker — Validate heading hierarchy on web pages
• Content Readability Checker — Analyze content readability scores