Schema APIvalidator.schema.org ↗
Validate JSON-LD, Microdata, and RDFa on any public URL. Get detected schema.org items, property trees, and error/warning details with character offsets.
What is the Schema API?
The validator.schema.org API exposes one endpoint — validate_url — that accepts a public web page URL and returns up to a dozen response fields covering every structured-data item detected on the page, their full property trees, and any validation errors or warnings with exact character offsets. It handles JSON-LD, Microdata, and RDFa markup in a single round trip, reporting counts, severity levels, and per-node error detail for each recognized schema.org type.
curl -X GET 'https://api.parse.bot/scraper/dd8d99d6-fa55-4109-b0fa-c72e2956cf1b/validate_url?url=https%3A%2F%2Fwww.bbc.com%2Fnews' \ -H 'X-API-Key: $PARSE_API_KEY'
Fetches the given public web page through the Schema.org validator and returns every structured-data item it detected, the item's nested property tree, and validation errors/warnings with their character offsets in the page source. One round trip per call; the validator renders the page server-side, so a call usually takes several seconds. If the validator could not fetch the page (unreachable host, blocked fetch), the call still succeeds with fetch_error set (e.g. NOT_FOUND), is_rendered false and an empty items list. A page that is fetched but contains no structured data returns num_objects 0 and an empty items list. A url that is not an absolute http(s) URL is rejected before any request.
| Param | Type | Description |
|---|---|---|
| urlrequired | string | Absolute http(s) URL of the public page whose structured data should be validated. |
{
"type": "object",
"fields": {
"url": "the page URL as reported back by the validator",
"items": "array of detected item groups, one per schema type, each with counts and a nodes array",
"errors": "array of page-level validation errors: error_type (e.g. INVALID_PREDICATE), args, severity (ERROR/WARNING), is_severe, begin/end character offsets in the page source",
"fetch_error": "null when the page was fetched; otherwise the validator's fetch failure code (e.g. NOT_FOUND)",
"is_rendered": "boolean, whether the validator fetched and rendered the page",
"num_objects": "integer, number of top-level structured-data nodes detected",
"total_errors": "integer, validation errors across the whole page",
"items[*].type": "schema.org type name of the group (null when the markup has no recognised type)",
"items[*].nodes": "array of node trees; each node has type, types, id, properties (name/value/errors), nested (name/node/errors, recursive), num_errors, num_warnings",
"total_warnings": "integer, validation warnings across the whole page"
},
"sample": {
"data": {
"url": "https://www.bbc.com/news",
"items": [
{
"type": "WebPage",
"nodes": [
{
"id": null,
"type": "WebPage",
"types": [
"WebPage"
],
"errors": [],
"nested": [
{
"name": "publisher",
"node": {
"id": null,
"type": "NewsMediaOrganization",
"types": [
"NewsMediaOrganization"
],
"errors": [],
"nested": [],
"num_errors": 0,
"properties": [
{
"name": "name",
"value": "BBC News",
"errors": []
}
],
"num_warnings": 0
},
"errors": []
}
],
"num_errors": 0,
"properties": [
{
"name": "url",
"value": "https://www.bbc.com/news",
"errors": []
},
{
"name": "name",
"value": "BBC News - Breaking news, video and the latest top stories from the U.S. and around the world",
"errors": []
}
],
"num_warnings": 0
}
],
"num_errors": 0,
"num_warnings": 0,
"num_nodes_with_error": 0,
"num_nodes_with_warning": 0
}
],
"errors": [],
"fetch_error": null,
"is_rendered": true,
"num_objects": 1,
"total_errors": 0,
"total_warnings": 0
},
"status": "success"
}
}About the Schema API
What the API returns
The validate_url endpoint takes a single required parameter — url, an absolute http(s) address of a public page — and returns a structured result covering everything the Schema.org validator found. Top-level fields include num_objects (count of detected structured-data nodes), total_errors, total_warnings, is_rendered (whether the page was fully rendered before analysis), and fetch_error (null on success, or a failure code such as NOT_FOUND when the page could not be retrieved).
Item and node detail
The items array groups detected markup by schema.org type. Each entry carries items[*].type (the type name, or null for unrecognized markup) and items[*].nodes — an array of fully resolved node trees. Each node exposes its type, types, id, a properties array with name/value pairs and per-property errors, and a recursive nested structure for embedded types. This lets you traverse an entire Product → Offer → PriceSpecification hierarchy in one response.
Validation errors and fetch behavior
The errors array at the page level lists each issue with its error_type (for example INVALID_PREDICATE), associated args, severity (ERROR or WARNING), is_severe flag, and begin/end character offsets into the original page source. Those offsets make it straightforward to highlight the exact location of a problem in a diff view or editor integration. When a page is completely inaccessible, fetch_error carries the validator's failure code so callers can distinguish a network problem from a markup error.
The Schema API is a managed, monitored endpoint for validator.schema.org — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when validator.schema.org changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official validator.schema.org API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Automated SEO audits: check pages for
total_errorsandtotal_warningsbefore and after deployment. - Content-management integrations: surface per-property validation errors to editors when they publish articles with Article or NewsArticle markup.
- E-commerce catalog QA: verify that Product and Offer nodes have required properties before indexing.
- CI/CD pipeline checks: fail a build when
is_severeerrors appear in JSON-LD on critical landing pages. - Structured-data monitoring: track
num_objectsandtotal_errorsover time to detect markup regressions. - Schema migration tooling: compare node trees before and after switching from Microdata to JSON-LD by diffing the
itemsresponse.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does validator.schema.org have an official developer API?+
What does the `validate_url` endpoint return for a page with no structured data?+
num_objects will be 0, items will be an empty array, and both total_errors and total_warnings will be 0. If the page itself could not be fetched, fetch_error will carry the failure code (such as NOT_FOUND) rather than null.Can I validate raw markup strings instead of a live URL?+
url parameter; it validates the structured data found at that address. You can fork this API on Parse and revise it to add a raw-markup or snippet-validation endpoint.Are there limitations on which pages can be validated?+
fetch_error instead of validation results. Local or localhost URLs are not supported.Does the API return the full source markup or only the parsed node trees?+
items array with character offsets in errors[*].begin and errors[*].end, but it does not return the raw page HTML or the original markup text. You can fork this API on Parse and revise it to include the source fragment alongside each error offset.