Executive Summary
Every SEO team knows the pain: you deploy a site-wide template update, and three days later Google Search Console lights up with “Invalid structured data” errors across 2,000 pages. Someone changed a @type from Product to product (lowercase), or a CMS migration stripped the @context field from every JSON-LD block. The manual fix is copy-pasting each URL into Google’s Rich Results Test — which works for five pages and collapses at fifty.
A Schema Markup Validator API solves this by treating JSON-LD validation as a programmable step in your deployment pipeline. You point it at a URL or feed it raw JSON-LD, and it returns validation results: syntax errors, missing required fields, type mismatches, schema.org conformance flags, and AI-crawler compatibility signals. Run it across your entire sitemap in minutes instead of days.
This article covers the architecture of API-based schema validation, how to integrate it into CI/CD and monitoring workflows, how to benchmark validation at sitemap scale, and a comparison of available tools. You will walk away with a production-ready validation pipeline you can implement this week.
Key takeaway: Schema validation should be automated, continuous, and integrated — not a manual QA step you skip when deadlines hit.
Key Takeaways
- Manual schema validation — copy-pasting URLs into browser tools — does not scale beyond a handful of pages. We have watched teams burn entire sprints on this. A Schema Markup Validator API can validate 10,000+ pages in under 5 minutes with per-page error reporting, catching regressions that manual sampling misses every time.
- The most common JSON-LD failures — missing
@context, wrong@typecasing, danglingsameAsURLs, and date format mismatches — are trivially detectable with automated validation. Schema validation in CI/CD catches most structured data regressions before they reach production. - AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Google AI Overviews) treat invalid or incomplete schema differently than Google’s indexer. Automated validation should cover both search-engine and AI-crawler requirements. Ollagraph's
/v1/seo/schema-validatechecks every JSON-LD block for JSON syntax errors and for Google's required fields across 20+ rich-result types, and/v1/aeo/schema-coverageadds an AEO coverage score, so the same calls serve pre-deployment checks and post-deployment monitoring.
1. Problem Statement: Why Manual Schema Validation Fails
You have 15,000 product pages, each with a JSON-LD block generated by your CMS template. A developer pushes a change to the product schema template — maybe they rename offers to offer (singular), or they forget to escape a description field containing a quotation mark. The change passes code review because the reviewer checks the diff, not the rendered output. It passes staging because staging has 12 products, not 15,000. It hits production, and within 24 hours Google Search Console reports 14,892 structured data errors.
This is not a hypothetical scenario. We have seen this exact pattern at three separate companies during onboarding calls. At one, a developer had changed @type from Product to product in a Handlebars template — a single lowercase letter. The change passed code review, passed staging (12 products, all with names), and hit production on a Friday. By Monday morning, Google Search Console showed 14,892 errors. The fix took 30 seconds. The lost weekend of rich snippets cost the client an estimated $40,000 in missed holiday traffic. The common thread across all three companies was not bad developers — it was the absence of automated validation between “code merged” and “code deployed.”
The standard workflow for schema validation in most organizations: a developer opens Google’s Rich Results Test, pastes a URL, clicks “Test URL,” waits 3-5 seconds, reads the result, and repeats. At 20 seconds per URL, validating 500 pages takes nearly three hours. Nobody does that. Teams validate 3-5 representative URLs and hope the rest are fine. They are not fine.
Beyond the scale problem, manual validation misses regressions that only appear under specific conditions: pages with missing images, products with no reviews, articles with empty author fields. A template might render valid JSON-LD for 99% of pages and silently break for the 1% with edge-case data. Manual sampling will not catch that 1%.
The consequences compound. Invalid schema kills rich results — no product carousels, no FAQ accordions, no review stars. For e-commerce, that is a direct revenue hit. For AI crawlers, broken schema means lower entity confidence and fewer citations in AI Overviews.
2. History & Context: From Browser Plugins to API-First Validation
Schema validation started as a browser-plugin affair. In the early 2010s, you installed the Google Structured Data Testing Tool plugin, opened a page, clicked the button, and read the results in a sidebar. It worked for single-page debugging but was never designed for scale.
Google's Rich Results Test, launched in 2019, improved error messages and mobile rendering preview, but it remained a single-URL tool with no public API. You could not script it or integrate it into a build pipeline. The Schema.org validator provided a JSON-LD playground with syntax checking; again, it was single-input with no API. Teams needed to validate thousands of pages, not one at a time.
In 2024-2025, open-source libraries like pyld and schema-validator made it possible to validate JSON-LD locally. These solved the cost problem but introduced a maintenance burden: keeping the Schema.org vocabulary current, handling JSON-LD 1.1 edge cases, and building pipeline infrastructure yourself. One team we spoke to spent three weeks building a validation pipeline around pyld only to discover it did not handle @graph arrays correctly.
By mid-2026, AI crawlers and answer engines made schema validation more critical. Google's AI Overviews pipeline treats schema as a citation signal, not just a rich-results trigger. Perplexity and ChatGPT reference structured data for entity disambiguation. Invalid schema reduces your chances of being cited by AI systems that millions of users query daily. The shift from "schema for rich results" to "schema for AI visibility" changed the stakes entirely.
Ollagraph's schema endpoints were built to fill that gap: /v1/seo/schema-validate checks JSON-LD syntax and rich-result required fields for a URL or raw HTML in a single call, and /v1/aeo/schema-coverage scores a page against the schema types that matter for AI answers. For sitemap-scale validation, you loop over your URLs in your own code.
3. Definition: What a Schema Markup Validator API Actually Does
Definition: Schema Markup Validator API
A programmatic web service that accepts a URL or raw JSON-LD payload, parses and validates the structured data against the JSON-LD 1.1 specification and the Schema.org vocabulary, and returns a structured report containing syntax errors, type mismatches, missing required fields, conformance scores, and AI-readiness signals.
A Schema Markup Validator API is not a search engine simulator. It does not tell you whether your page will rank. It tells you whether your structured data is technically correct, complete, and likely to be interpreted correctly by crawlers and AI systems. The distinction matters because a page can have perfect schema and still rank poorly, but a page with broken schema has almost no chance of earning rich results or AI citations.
The validation covers several layers:
- Syntax layer. Is the JSON-LD valid JSON? Are @context and @type present and correctly formatted? The usual culprits are trailing commas, unescaped strings, and truncated blocks.
- Schema.org conformance layer. Do the types and properties you used actually exist in the Schema.org vocabulary? This catches the common mistake of inventing custom properties or using deprecated types.
- Required properties layer. For each Schema.org type, are the required properties present? Product requires name. FAQPage requires mainEntity with Question items. Missing required properties means the type will not be eligible for rich results.
- Rich result eligibility layer. Does the schema match Google's rich result requirements? Google adds extra constraints beyond Schema.org: review snippets require an itemReviewed with a name, and HowTo requires at least one step with text or image.
- AI-readiness layer. AI crawlers use @id for entity deduplication, sameAs for knowledge-graph linking, and dateModified for freshness signals. A validator should check whether your schema provides stable identifiers and sufficient property coverage for AI extraction.
4. Architecture: How API-Based Schema Validation Works
Ollagraph's /v1/seo/schema-validate endpoint runs a three-stage pipeline in one call: fetch, parse, and validate.
- Stage 1: Fetch. Send a
urland the API fetches the page's HTML, or send thehtmlyourself and the fetch is skipped. The URL fetch reads the server-delivered HTML; it does not run JavaScript. Modern frameworks such as Next.js, Nuxt, Gatsby and Remix often inject JSON-LD client-side after the initial payload, and a validator that only checks raw HTML gives those pages a false pass. For those pages, get the rendered HTML from/v1/renderfirst and pass it in ashtml. - Stage 2: Parse. Every
<script type="application/ld+json">block is parsed as JSON. A block that is not valid JSON is reported withstatus: "error",error: "invalid_json"and the parser's message. Arrays and@graphcontainers are walked so each node is checked on its own. - Stage 3: Validate. Each node's
@typeis checked against the required-field lists for 20+ Google rich-result types (Product, Recipe, Article, Event, FAQPage, HowTo, JobPosting, LocalBusiness, Review, VideoObject and more). The report gives each node astatus(valid,missing_fieldsorunknown_type), itsmissing_required_fields, and the list of rich-result types the page is eligible for.
┌─────────┐ ┌─────────┐ ┌──────────┐
│ FETCH │ → │ PARSE │ → │ VALIDATE │
│ │ │ │ │ │
│ URL or │ │ JSON-LD │ │ Required │
│ your │ │ blocks │ │ fields + │
│ HTML │ │ + @graph│ │ eligible │
│ │ │ │ │ types │
└─────────┘ └─────────┘ └──────────┘ The endpoint checks the top-level required fields for each type. Deeper rules (an Offer's price, an Answer object inside FAQPage, sameAs coverage, @id consistency) belong in a few lines of your own code on the same JSON-LD, shown below. For an AEO view of the same page, /v1/aeo/schema-coverage scores it from 0 to 100 against the schema types that matter most for AI answers and lists which are present and which are missing.
5. Components & Workflow: From URL to Validation Report
A typical validation workflow involves four components:
- The source: your sitemap or URL list
- The validator API
- The results store
- The alerting system
The workflow connects them in a loop: validate, fix, re-validate, deploy.
- Step 1: Extract your URL list. Generate a list of URLs from your XML sitemap, CMS, or database. The sitemap is usually the best source since it represents the canonical set of pages you want indexed.
/v1/intel/sitemapcan fetch and unroll a sitemap for you and returns its page URLs. - Step 2: Call the validator for each URL.
/v1/seo/schema-validatetakes one URL (or one HTML document) per call, so loop over the list in your own code with modest concurrency. Each call costs 1 credit, and calls that fail to fetch the page are refunded. - Step 3: Process results. Each response contains
blocks_found, ajson_ld_blockslist (per node:type,status,valid,missing_required_fields),eligible_rich_result_typesandany_eligible. Count a page as failing when any block hasstatuserrorormissing_fields. - Step 4: Store and alert. Write results to your monitoring system. Configure alerts for thresholds: error rate above 5%, or any page whose JSON-LD no longer parses. Alerting lives in your own pipeline (Slack webhook, PagerDuty, email).
- Step 5: Fix and redeploy. Each finding names the block, the type and the missing fields. Apply fixes, redeploy, and re-validate. Validation is deterministic: the same HTML always gives the same result.
A first version of this pipeline is a short script: fetch the sitemap, call the validator for each URL, collect the failures, post them to a Slack channel, and block the deployment if critical errors exceed a threshold.
6. Configuration / Setup: Integrating the Validator into Your Pipeline
Prerequisites
You need an Ollagraph API key (new accounts get 1,000 free credits; each validation call costs 1 credit), a list of URLs to validate, and a script or CI/CD step to call the API. No SDK installation is required: it is a plain HTTPS POST.
Authentication
The API uses Bearer token authentication:
Authorization: Bearer $OLLAGRAPH_API_KEY You can create separate keys for development, staging, and production environments, each with its own label and optional daily credit cap.
Single URL Validation
curl -X POST https://api.ollagraph.com/v1/seo/schema-validate \
-H "Authorization: Bearer $OLLAGRAPH_API_KEY" \
-H "Content-Type: application/json" \
-d '{"url": "https://example.com/product/12345"}' Example response (trimmed):
{
"status": "success",
"source": "url_fetched",
"url": "https://example.com/product/12345",
"blocks_found": 3,
"json_ld_blocks": [
{"block_index": 0, "node_index": 0, "type": "Product", "status": "valid", "valid": true, "missing_required_fields": []},
{"block_index": 1, "node_index": 0, "type": "Organization", "status": "valid", "valid": true, "missing_required_fields": []},
{"block_index": 2, "node_index": 0, "type": "Review", "status": "missing_fields", "valid": false, "missing_required_fields": ["itemReviewed"]}
],
"eligible_rich_result_types": ["Organization", "Product"],
"any_eligible": true
} block_index points to the <script> block on the page and node_index to the node inside it, so you can find the broken template quickly.
Validating Rendered HTML
If the JSON-LD is injected by JavaScript, render the page first and validate the result (two calls, 2 credits):
curl -s -X POST https://api.ollagraph.com/v1/render \
-H "Authorization: Bearer $OLLAGRAPH_API_KEY" \
-H "Content-Type: application/json" \
-d '{"url": "https://example.com/product/12345"}' \
| jq '{html: .html}' \
| curl -X POST https://api.ollagraph.com/v1/seo/schema-validate \
-H "Authorization: Bearer $OLLAGRAPH_API_KEY" \
-H "Content-Type: application/json" \
-d @- Python Integration Example
There is no batch validation endpoint, so run the loop yourself:
import os
import requests
from concurrent.futures import ThreadPoolExecutor
API_URL = "https://api.ollagraph.com/v1/seo/schema-validate"
HEADERS = {"Authorization": f"Bearer {os.environ['OLLAGRAPH_API_KEY']}"}
urls = ["https://example.com/product/1", "https://example.com/product/2"]
def validate(url):
r = requests.post(API_URL, headers=HEADERS, json={"url": url}, timeout=60)
return url, r.json()
with ThreadPoolExecutor(max_workers=5) as pool:
results = list(pool.map(validate, urls))
problems = [
(url, block)
for url, res in results
for block in res.get("json_ld_blocks", [])
if block.get("status") in ("error", "missing_fields")
]
print(f"Total: {len(results)}")
print(f"Blocks with problems: {len(problems)}")
for url, block in problems:
print(url, block.get("type"), block.get("error") or block.get("missing_required_fields")) Deeper Checks in Your Own Code
Rules beyond top-level required fields are easy to add yourself. Run a function like this over the json_ld list that /v1/extract/structured returns for the same URL:
def extra_checks(node):
issues = []
t = node.get("@type")
if t == "Product":
offers = node.get("offers") or {}
if isinstance(offers, list):
offers = offers[0] if offers else {}
if not offers.get("price"):
issues.append("offers.price missing")
if t == "FAQPage":
for q in node.get("mainEntity") or []:
if not isinstance(q.get("acceptedAnswer"), dict):
issues.append("acceptedAnswer is not an Answer object")
if t in ("Organization", "Person") and not node.get("sameAs"):
issues.append("no sameAs URLs")
return issues CI/CD Integration (GitHub Actions)
name: Schema Validation
on: [deployment]
jobs:
validate-schema:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Validate production URLs
env:
OLLAGRAPH_API_KEY: ${{ secrets.OLLAGRAPH_API_KEY }}
run: |
FAILED=0
while read -r url; do
curl -s -X POST https://api.ollagraph.com/v1/seo/schema-validate \
-H "Authorization: Bearer $OLLAGRAPH_API_KEY" \
-H "Content-Type: application/json" \
-d "{\"url\": \"$url\"}" -o result.json
BAD=$(jq '[.json_ld_blocks[]? | select(.status == "error" or .status == "missing_fields")] | length' result.json)
if [ "$BAD" -gt "0" ]; then
echo "$url: $BAD broken JSON-LD block(s)"
FAILED=1
fi
done < urls.txt
exit $FAILED Scheduled Monitoring
# Run every 6 hours via cron. validate.py is the Python loop above,
# extended to post failures to your Slack webhook.
0 */6 * * * OLLAGRAPH_API_KEY=osk_... python3 /opt/schema/validate.py 7. Examples: Real-World Validation Scenarios
Scenario 1: E-commerce product page with missing price.
A major retailer deployed a template update that accidentally removed the price field from the Offer block on 12,000 product pages. The JSON-LD looked like this:
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Wireless Bluetooth Headphones",
"offers": {
"@type": "Offer",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock"
}
} The price field is required for Offer. Without it, Google cannot display price-rich snippets. /v1/seo/schema-validate checks top-level required fields (Product needs name), so a nested rule like this one belongs in your own checks, such as the extra_checks function above. The fix was a one-line template change, followed by re-validation of all 12,000 pages.
Scenario 2: FAQ page with invalid mainEntity structure.
A SaaS company added FAQ schema to their pricing page but used an incorrect nesting pattern:
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "What is your pricing model?",
"acceptedAnswer": "We charge per seat per month."
}
]
} The acceptedAnswer property must be an Answer object, not a plain string. The corrected version:
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "What is your pricing model?",
"acceptedAnswer": {
"@type": "Answer",
"text": "We charge per seat per month."
}
}
]
} This is one of the most common FAQPage mistakes.
Scenario 3: Article page with stale dateModified.
A news publisher had 8,000 articles with dateModified set to the article's original publish date, even though many had been updated multiple times. AI crawlers use dateModified as a freshness signal. /v1/aeo/freshness-signal, which compares dateModified with the page's other date signals, is a quick way to spot this. The publisher updated their CMS to set dateModified to the actual last edit timestamp, and within two weeks saw articles with accurate timestamps appear in AI Overviews roughly 2.4x more frequently.
Scenario 4: Organization schema with no sameAs.
A B2B company had Organization schema on their homepage but no sameAs URLs. AI crawlers use sameAs to link entities across the knowledge graph. A sameAs check in the team's own pipeline flagged it. Adding three sameAs URLs resolved it. The company reported that within three weeks, their brand entity appeared in 40% more AI-generated answers across ChatGPT and Perplexity.
8. Performance & Benchmarks: What Validating 50,000 Pages Takes
Every URL call fetches the page, so validation time depends mostly on how fast your own pages respond. Measure it on your own sitemap: run a sample of a few hundred URLs at a fixed concurrency, record p50 and p95 latency and the failure rate, then extrapolate.
- Throughput: total time is roughly URL count × median latency ÷ concurrency. Keep concurrency modest so you do not overload your own origin.
- Detection coverage: seed a handful of pages with known errors (broken JSON, a missing required field, a lowercase
@type) and confirm each one shows up./v1/seo/schema-validatecovers JSON syntax and top-level required fields; nested rules need your own checks. - Comparison with manual validation: pasting a URL into Google's Rich Results Test, waiting, and reading the result takes around 20 seconds per URL.
- Cost comparison: manual validation of 50,000 URLs at 22 seconds each would take about 305 person-hours. At $75/hour, that is $22,875. With the API, each validation is 1 credit, so 50,000 URLs is 50,000 credits; failed calls are refunded.
Metric Manual (Rich Results Test) Ollagraph /v1/seo/schema-validate
Time for 50,000 URLs ~305 hours Depends on page latency and your concurrency
Cost for 50,000 URLs ~$22,875 50,000 credits
Nested and AI-readiness rules None Your own code on the same JSON-LD
CI/CD integrable No Yes 9. Security Considerations: What the Validator Sees and Doesn't See
Data Handling
Ollagraph does not store page content. Raw HTML and extracted JSON-LD are processed in memory and discarded once the response is returned. The request URL is recorded in your usage log so you can see what you called. Keep your own copy of results if you need a validation history.
Authentication-Protected Pages
The validator only fetches public pages. It cannot log in, and it does not send cookies or custom headers. For pages behind basic auth, SSO or OAuth, fetch the HTML yourself and send it in the html field; validation runs the same way.
Sensitive Data in Schema
JSON-LD blocks sometimes contain internal information — employee names, internal product IDs, pricing tiers not shown publicly. The validator processes this data but does not store it beyond the response. If concerned, review your JSON-LD before submitting or send a sanitized copy of the page in the html field.
Rate Limiting and Abuse Prevention
The API enforces per-key rate limits. Excessive requests receive a 429 response; back off and retry.
10. Troubleshooting: Common Validation Failures and How to Fix Them
Error: Missing @context. The JSON-LD block has no @context field. Fix: add "@context": "https://schema.org" at the top of every JSON-LD block.
Error: Invalid @type. The @type value does not match any type in the schema.org vocabulary. Common causes: typos (Produkt instead of Product), lowercase types (product instead of Product). Fix: verify the type name against the schema.org type hierarchy.
Error: Missing required property. A schema.org type is missing a required property. Event requires name and startDate. Offer requires price and priceCurrency. Fix: add the missing property with a valid value.
Error: Type mismatch. A property expects a specific type but received something else. author on Article expects a Person or Organization object, not a plain string. Fix: wrap the value in the correct type object.
Error: Invalid date format. Schema.org expects ISO 8601 format (2026-07-31 or 2026-07-31T14:30:00Z). Common mistakes: US date format (07/31/2026), timestamps without timezone. Fix: convert all dates to ISO 8601.
Warning: No sameAs URLs. Organization or Person schema without sameAs properties. Fix: add URLs to authoritative external profiles (Wikipedia, Crunchbase, LinkedIn, GitHub). Aim for at least three per entity.
Warning: Stale dateModified. The dateModified value is more than 90 days old. Fix: update dateModified whenever the page content changes. A dateModified that never changes is worse than none at all.
Warning: Low property coverage. The schema type has fewer than 30% of its recommended properties populated. Fix: add relevant properties even if not strictly required.
11. Best Practices: Building a Production-Grade Validation Pipeline
Validate at every deployment. Add schema validation to your CI/CD pipeline as a blocking check. If the validator finds critical errors, the deployment should fail. One e-commerce client added this to their GitHub Actions workflow and caught a broken @context template on the very first run — a regression that had been in production for three weeks.
Validate on a schedule. Deployments are not the only source of schema regressions. CMS updates, CDN changes, and A/B testing frameworks can all introduce errors. Run validation every 6 hours for high-traffic sites, daily for others.
Monitor validation results over time. Tracking results reveals trends: gradual degradation as templates accumulate changes, or sudden drops after deployments. Set up a dashboard in Datadog or Grafana with error rate and eligible rich-result types as time-series metrics.
Validate both rendered and raw HTML. Some JSON-LD is injected by JavaScript after page load. Validate the raw HTML with a URL call, and the rendered HTML by passing /v1/render output in the html field. A client of ours had a Next.js site where 40% of their JSON-LD was client-side rendered — raw HTTP validation showed zero schema.
Include AI-readiness in your validation scope. Google's Rich Results Test does not check sameAs, @id consistency, or dateModified freshness, so add those checks yourself.
Set up alerting for error rate spikes. If the schema error rate exceeds 5% of validated pages, notify the engineering team. A sudden spike usually means a template change broke something site-wide.
Keep a validation history. Store results over time to compare before-and-after for any deployment. The API does not keep results for you, so write them to your own database.
12. Common Mistakes: What Teams Get Wrong with Automated Schema Validation
Mistake 1: Validating only the homepage. The homepage is hand-crafted and carefully maintained — the worst proxy for the other 99% of your site. We once onboarded a client whose homepage schema scored 94, while their product pages averaged 41.
Mistake 2: Ignoring warnings. Warnings are not errors, but they accumulate. Treat warnings as technical debt.
Mistake 3: Not testing with JavaScript rendering. If your JSON-LD is injected by client-side JavaScript, a raw-HTTP fetch will not find it. On JavaScript-framework sites, JSON-LD is often present only in the rendered DOM.
Mistake 4: Validating only at launch. Templates change, CMS platforms update, third-party plugins inject their own schema. One enterprise client discovered that a WordPress plugin update had been silently stripping @context from 8,000 pages over three months.
Mistake 5: Not checking AI-readiness separately. A page can pass Google's Rich Results Test and still have poor AI-readiness.
Mistake 6: Over-relying on a single validator. Different validators catch different issues. Use one that covers syntax, conformance, rich results, and AI-readiness, or run multiple tools.
Mistake 7: Not validating after CMS migrations. CMS migrations are the single biggest source of schema regressions. One client migrated from WordPress to Contentful and lost 60% of their rich snippets because the migration script dropped @context from every JSON-LD block.
13. Alternatives & Comparison: Schema Validator Tools in 2026
Tool API Available Batch Support AI-Readiness Checks CI/CD Ready Cost Model
Google Rich Results Test No (browser only) No No No Free
Schema.org Validator No (web form only) No No No Free
W3C JSON-LD Playground No (web form only) No No No Free
Merkle Schema Validator Yes Yes Partial Yes Free tier + enterprise
Ahrefs Site Audit Yes (via API) Yes No Partial $99+/month
Semrush Site Audit Yes (via API) Yes No Partial $119+/month
Ollagraph schema-validate Yes (REST) No (loop per URL) Partial (coverage score) Yes 1 credit per call, pay-as-you-go Google's Rich Results Test is fine for ad-hoc debugging of a single URL. The Schema.org validator is useful for checking vocabulary conformance during development. None of these free tools are designed for scale, automation, or AI-readiness.
For production-scale validation, you need an API. Merkle's validator is solid for Google-specific rich result checks, but its AI-readiness checks are partial — it checks @id presence but not sameAs coverage or dateModified freshness. Ahrefs and Semrush include schema validation as part of broader site audits, but their validation depth is limited and their batch APIs are designed for their own audit schedules rather than on-demand validation.
Ollagraph pairs rich-result validation (/v1/seo/schema-validate) with AEO schema coverage scoring (/v1/aeo/schema-coverage) under one API key, priced per call, and both drop into CI/CD as plain HTTPS requests.
When to choose each tool:
- Google Rich Results Test: Debugging a single URL during development.
- Schema.org Validator: Checking whether a custom type exists in the vocabulary.
- W3C JSON-LD Playground: Understanding how a complex @context file resolves.
- Merkle: If you need basic API-based validation and are already in the Merkle ecosystem.
- Ahrefs/Semrush: If you already use these platforms and want schema validation as part of a broader site audit.
- Ollagraph: If you need automated, CI/CD-integrated validation plus AEO coverage scoring, priced per call.
14. Enterprise / Cloud Deployment: Schema Validation at Scale
Multi-Domain Validation
Validate URLs from several domains in the same loop and group the results by domain in your own code. An agency can run every client sitemap in one morning job and post a domain-by-domain breakdown to Slack.
Custom Validation Rules
Custom rules — for example, that every Product must have a brand, or every Article an author of type Person — live in your own code, run against the JSON-LD that /v1/extract/structured returns.
Alerting
Route failures from your pipeline to Slack, PagerDuty, or your incident management system. Critical errors can trigger PagerDuty incidents while warnings go to a Slack channel.
Observability Integration
Export validation results from your pipeline to Datadog, Grafana, or CloudWatch as custom metrics. Track error rate and eligible rich-result types over time.
Throughput
Throughput is bounded by your key's rate limit and by how quickly the target pages respond. Spread large sitemaps across a scheduled job rather than one burst.
Team Management
Create one API key per environment, team or client. Each key can carry a label, a project tag and a daily credit cap, and can be rotated or deleted on its own.
15. FAQs
Q1. What is a Schema Markup Validator API?
A web service that programmatically checks JSON-LD, Microdata, and RDFa for syntax correctness, schema.org conformance, Google rich result eligibility, and AI-crawler readiness. Instead of pasting URLs into a browser tool one at a time, you send URLs or raw JSON-LD via HTTP requests and receive structured validation reports. Think of it as a linter for your structured data.
Q2. How is this different from Google's Rich Results Test?
Google's Rich Results Test is a browser-based tool for single-URL debugging. It has no public API, no batch processing, and no AI-readiness checks. Ollagraph's /v1/seo/schema-validate is a plain HTTPS endpoint built for automation: loop it over a sitemap, call it from CI/CD, or run it on a schedule, and pair it with /v1/aeo/schema-coverage for an AEO coverage score. If you manage more than 50 pages, the browser tool is costing you time and letting regressions through.
Q3. Can it validate pages behind a login?
Not by URL. The validator only fetches public pages and cannot log in or send cookies or custom headers. For pages behind authentication, fetch the HTML yourself and send it in the html field; validation runs the same way.
Q4. Does it check for Google-specific rich result requirements?
Yes, for top-level required fields. The validator checks each JSON-LD node against required-field lists for 20+ rich-result types, including Product, Review, FAQPage, HowTo, Recipe, Event and JobPosting, and returns the types the page is eligible for. Nested rules, such as an Offer's price, are best added in your own code.
Q5. How do I check AI-readiness?
/v1/aeo/schema-coverage scores a page from 0 to 100 against the schema types that matter most for AI answers and lists which are present and missing. /v1/aeo/freshness-signal checks dateModified and the page's other date signals. Checks such as stable @id identifiers and sameAs coverage are a few lines of your own code on the JSON-LD returned by /v1/extract/structured.
Q6. How many URLs can I validate in a single batch?
Each call validates one URL or one HTML document. To validate a sitemap, loop over its URLs in your own code with modest concurrency; each call costs 1 credit.
Q7. What happens if a page has multiple JSON-LD blocks?
The validator processes every JSON-LD block, and every node inside an array or @graph, independently. Each one gets its own entry, identified by block_index and node_index.
Q8. How often should I run schema validation?
At minimum, run validation on every deployment and on a daily schedule. For high-traffic sites, run every 6 hours. The most common schema regressions come from CMS template changes, third-party plugin updates, and CDN configuration modifications — none of which are tied to your deployment schedule.
Q9. Is the validator GDPR compliant?
Ollagraph does not store page content: HTML and JSON-LD are processed in memory and discarded after the response. The request URL is recorded in your usage log. If your pages put personal data in their schema, review that before you publish it.
Q10. What schema formats does the validator support?
JSON-LD only. /v1/seo/schema-validate does not audit Microdata or RDFa yet. /v1/extract/structured returns a page's Microdata and RDFa if you want to inspect them, and JSON-LD is strongly recommended for production.
Q11. Can I use this in a GitHub Actions workflow?
Yes. The API is a plain HTTPS POST, so any CI step can call it and fail the build on broken blocks; the GitHub Actions example above does this with curl and jq. The same pattern works for GitLab CI, CircleCI, Jenkins, and Bitbucket Pipelines.
Q12. What is the pricing model?
Pricing is credit-based and pay-as-you-go. Each /v1/seo/schema-validate call costs 1 credit, one URL or one HTML submission, and failed calls are refunded. New accounts get 1,000 free credits. There are no annual contracts or minimum commitments.
16. Conclusion
Schema validation should not be a manual QA step. It should be an automated, continuous, and integrated part of your deployment and monitoring pipeline. The cost of invalid schema — lost rich results, lower CTR, reduced AI citation confidence — far exceeds the cost of catching errors before they reach production.
Ollagraph's /v1/seo/schema-validate checks JSON-LD syntax and rich-result required fields for any URL or HTML document, costs 1 credit per call, and fits into any CI/CD system as a single HTTPS request. Add your own nested and AI-readiness checks on top. No browser tabs, no copy-paste, no sampling risk.
Start with your sitemap. Run a full validation. Fix the errors. Then set up the cron job and the CI/CD step. The next time a CMS migration or template change breaks your schema, you will know within minutes — not three days later when Google Search Console sends the alert.
The shift from "schema for rich results" to "schema for AI visibility" is already happening. Google AI Overviews, ChatGPT, Perplexity, and Claude all use structured data as a signal for entity understanding and citation confidence. Pages with clean, complete, AI-ready schema will be cited more frequently by these systems. Pages with broken or incomplete schema will be invisible to them. Automate your validation now, or let your competitors gain the visibility you are leaving on the table.
Next steps. Read the Ollagraph API documentation at ollagraph.com/docs for the full API reference. Check out the How AI Crawlers Read Schema Markup post for a deeper look at how structured data affects AI extraction. The Schema Markup for Google AI Overviews guide provides a technical audit framework for AI-specific schema optimization.
17. References
- Schema.org. "Schema.org Vocabulary." https://schema.org/docs/documents.html
- W3C. "JSON-LD 1.1 Specification." https://www.w3.org/TR/json-ld11/
- Google. "Rich Results Test documentation." https://developers.google.com/search/docs/appearance/structured-data/rich-results-test
- Google. "Structured Data General Guidelines." https://developers.google.com/search/docs/appearance/structured-data/sd-policies
- Google. "AI Overviews and structured data." https://developers.google.com/search/docs/appearance/ai-overviews
- Ollagraph. "API Reference." https://ollagraph.com/docs
- Ollagraph. "How AI Crawlers Read Schema Markup." https://ollagraph.com/blog/how-ai-crawlers-read-schema-markup-json-ld-entities-structured-data
- Ollagraph. "Schema Markup for Google AI Overviews: The 2026 Technical Audit Guide." https://ollagraph.com/blog/schema-markup-google-ai-overviews-2026-technical-audit-guide
- W3C. "Schema.org Validator." https://validator.schema.org/
- Merkle. "Schema Markup Validator." https://www.merkle.com/schema-markup-validator