You added schema markup, ran a re-check a week later, and Search Console is showing red flags that weren't there before. Or maybe the page never validated in the first place, and the error message reads like it's written in a different language entirely.
Almost every JSON-LD error falls into one of a handful of repeat offenders — a stray comma, a required field left out, a type that doesn't match the page. None of them require deep technical knowledge to fix once you know what you're looking at.
Most JSON-LD errors come from broken syntax (a missing comma or bracket), a missing required property for the schema type, or a mismatch between the code and what's visible on the page. Fix syntax with a JSON validator, fix missing fields by checking schema.org's required properties for that type, and fix mismatches by editing the data to reflect the actual page content. Then re-check with Google's Rich Results Test.
What counts as a JSON-LD error?
A JSON-LD error is anything that stops a search engine from correctly reading the structured data block on a page. These fall into three distinct categories, and knowing which one you're dealing with changes how you fix it.
- Syntax errors. The JSON itself is malformed — a missing comma, an unclosed brace, or a stray quotation mark — so the block can't even be parsed as valid data.
- Schema errors. The JSON parses fine, but it's missing a property that schema.org requires for that type, or it uses a property that type doesn't support.
- Content mismatch errors. The code is technically valid, but it describes something that isn't actually present or visible on the page, which violates Google's structured data guidelines even though nothing "breaks."
The Rich Results Test and Search Console report all three under the umbrella of "errors" or "warnings," so the first step in fixing anything is figuring out which category the message actually belongs to.
Why fixing these errors matters
A page with broken JSON-LD isn't penalized the way thin content or spam is, but it does lose out on real, visible benefits:
- Lost rich results. A page that fails validation for a required property simply won't show the star rating, FAQ dropdown, or product details it was aiming for.
- Wasted markup effort. Time spent writing or generating schema is wasted if the block never validates, since search engines ignore anything they can't parse.
- Site-wide trust erosion. A pattern of mismatched or inaccurate structured data across many pages can make a search engine treat all of a site's markup with more caution.
- Delayed discovery. Errors that go unnoticed for months mean months of missed rich-result opportunities on pages that could otherwise qualify.
Step-by-step: finding and fixing JSON-LD errors
- Pull the exact error message. Open the flagged page in Google's Rich Results Test or Search Console and read the specific error text, not just the page-level warning count.
- Sort it into a category. Decide whether the message points to broken syntax, a missing required property, or a value that doesn't match the visible page.
- Run a syntax check first. Paste the raw JSON-LD into a JSON validator to catch misplaced commas, brackets, or quotes before touching anything else.
- Check the required fields for that type. Look up the schema type on schema.org and confirm every field it marks as required is present in your block.
- Compare the data against the page. Confirm every value in the JSON-LD — price, rating, author, date — is something a visitor can actually see on the live page.
- Re-paste and re-test. Update the snippet in your CMS's custom code or header field, then run the live URL back through the Rich Results Test.
- Set a recheck reminder. Errors tend to reappear after content updates, so a periodic re-validation catches drift before Search Console flags it publicly.
The most common JSON-LD errors
1. Trailing commas and unclosed brackets
The single most frequent cause of a fully broken block. It usually happens when someone edits a snippet by hand to update one value and leaves a comma behind after removing the last item in a list.
2. Missing required properties
Every schema type has a short list of properties it needs to be considered valid — for
example, FAQPage needs at least one question with an accepted answer. Leaving
one out produces a clear, specific error rather than a vague one.
3. Using a property that doesn't belong to the type
Copying a field from one schema type's example into a different type — like adding a
price property to an Article block — gets flagged because that
property isn't defined for that type.
4. Duplicate or conflicting blocks for the same entity
Having two separate JSON-LD blocks both describing the same page as an Article,
with different authors or dates in each, creates a conflict that search engines can't
reliably resolve.
5. Data that doesn't match the visible page
A rating, price, or availability status typed into the schema but nowhere on the actual page passes syntax and type checks while still violating structured data guidelines.
Real-world examples
How these errors typically show up, and what actually fixed each one:
recipeIngredient array; adding it cleared the error immediately.Error types compared
A side-by-side look at how the three main error categories differ in cause, detection, and fix.
| Error type | Typical cause | How it's caught | Fix |
|---|---|---|---|
| Syntax error | Hand-editing JSON — missing comma, bracket, or quote | Fails to parse entirely | Run through a JSON validator, correct the character |
| Schema error | Missing required property or invalid property for the type | Flagged as error/warning | Check schema.org's required fields for that type |
| Content mismatch | Data entered that isn't visible on the page | May pass validation, still a guideline issue | Remove or align the value with visible content |
| Duplicate entity | Multiple plugins or scripts describing the same entity | Usually visible on manual review | Consolidate into a single block |
Skip the error-hunting — generate clean schema instead
The Rebrixe Schema Generator builds syntax-correct JSON-LD for the most common schema types, so there's no bracket to misplace and no required field left blank. Fill in the form, copy the output, and validate with confidence.