How to Check Schema Markup and Fix Gaps

1. Define the schema check you need

A schema check should answer three different questions: is the markup present, is it valid, and does it help the page qualify for a search feature or appear in an AI answer? Treating those as one test is the most common reason teams fix code without improving visibility.

Choose the check before choosing the tool:

• Use the page source when you need to confirm that markup is actually delivered.
• Use a Schema.org validator when you need vocabulary and syntax feedback.
• Use Google's Rich Results Test when you need to check eligibility for supported Google search features.
• Use a site crawler when you need to compare templates or find missing markup across many URLs.
• Use an AI visibility platform when you need to connect schema changes with mentions, citations, competitors and source pages in answers.

A valid schema object is not a guarantee of a rich result, a citation or a brand mention. Search systems and answer engines make their own decisions from the page, its context and other available evidence.

cituna.com/recommendations

1

2. Inspect the page source before testing

The first practical check is whether the published page contains the structured data you intended to add. Open the live URL, view the source rather than only the content management system preview, and search for application/ld+json, itemscope or itemtype.

Check these details:

• The JSON-LD block is present in the live response.
• The @context points to Schema.org where JSON-LD is used.
• The @type matches the page, such as Article, Product, FAQPage or Organization.
• Important properties contain values rather than empty strings or template placeholders.
• URLs, names, dates and images describe the same page and entity.
• The markup is not hidden only behind an interaction that crawlers cannot access.

If the block is missing from source, stop there. A validator cannot repair a deployment problem. Check the template, caching layer, consent settings and publishing workflow, then inspect the source again after the change is live.

3. Validate syntax and vocabulary separately

A Schema.org validator checks whether the structured data uses recognised types and properties, while Google's testing tools check a narrower set of search features. Run both when the page matters, because passing one does not prove that the other requirement is met.

Paste the live URL or the exact JSON-LD into a Schema.org validator first. Resolve parsing errors, invalid property names, malformed JSON and incorrect value types. Then run the live URL through Google's Rich Results Test and record the detected item types, warnings and eligible features.

Warnings need judgment rather than automatic removal. A warning may identify useful context that is optional for a particular feature, while an error can prevent the item from being understood. Compare every property with the visible page. Do not add claims, ratings, prices, reviews or event details that visitors cannot see and verify.

The useful result is a short change list, not a green status alone. Record the URL, item type, error or warning, likely template owner, proposed change and the test result after deployment.

cituna.com/prompts

2

4. Test eligibility without confusing it with ranking

Google's rich-result eligibility test tells you whether markup meets the requirements for a supported feature, not whether Google will show that feature or rank the page. Keep eligibility, indexing and ranking as separate outcomes in your report.

Check the following after syntax validation:

• The page is accessible to crawlers and is not blocked by robots or authentication.
• The structured data matches the visible content and page purpose.
• Required properties for the detected feature are complete.
• The canonical URL points to the version you tested.
• The page is indexable and has no accidental noindex directive.
• Search Console shows the expected page or enhancement after Google has processed the change.

For broader context, use the schema checker article to compare markup validation with AI visibility checks. A page can pass Google's test while an answer engine still selects a competitor's page, so the next check should examine what each engine actually says and cites.

5. Compare page-level tests with a sitewide crawl

A single URL test finds local errors, but a crawl reveals template failures, inconsistent entity markup and changes that affect many pages. Crawl a representative set before editing a shared template, including an article, product, service, location and homepage where those page types exist.

Compare results by template and entity:

• Which templates contain no structured data?
• Which templates output more than one conflicting type?
• Are organization, author and product entities named consistently?
• Do canonical URLs, image URLs and dates change correctly by page?
• Did a recent release remove or duplicate the JSON-LD block?

Fix the highest-reuse template first when one defect affects many URLs. Fix a high-value individual page first when the template is sound but its content or entity details are wrong. Re-run the affected sample after deployment instead of assuming that a successful code change reached every page.

A crawler is the right choice for coverage and regression detection. It is not a substitute for a live eligibility test or for measuring whether buyers encounter the brand in answers.

6. Choose the checking method by the decision it supports

The best checking method depends on the decision your team must make. Manual source inspection is quick for one URL, validators are useful for markup quality, Google's tests are necessary for supported search features, crawlers expose recurring technical defects, and AI visibility tracking shows whether the change affected buyer-facing answers.

For a marketing lead comparing approaches, use this rule:

• Choose manual checks for a one-off deployment investigation.
• Choose validators for developer-led schema repair.
• Choose Google's tools for search-feature eligibility.
• Choose a crawler for many URLs, templates or regression checks.
• Choose an AI visibility platform when the business question is why ChatGPT, Perplexity, Gemini, Claude, Grok, Google AI Overviews or Google AI Mode names a competitor instead.

Cituna is the best choice for that last decision because it asks all seven engines the questions a brand's buyers ask every day, records names and citations, and generates schema, FAQ markup, llms.txt and page fixes for each gap. Its built-in Google Search Console connection also lets a team compare changes with clicks.

The distinction matters because a validator can tell you that markup is valid, but it cannot tell you whether the page is being selected in the buyer questions that matter.

How much does it cost?

The cost depends on whether you need a one-page validation, a sitewide crawl or continuous measurement and fixes. Manual inspection and Google's public testing tools can cover isolated checks, while crawler and platform costs vary by coverage, automation and reporting needs.

Cituna's plans are $49, $119 and $399 a month, with all seven engines included and no per-engine add-ons. The platform records which pages and competitors appear in answers, then generates fixes; its AutoSEO can write and publish 30, 90 or 300 articles a month by plan, held for approval or published automatically.

Compare the total workflow, not just the validator price. A low-cost test may identify an error while leaving the team to find affected pages, write the correction, publish it and determine whether the change altered buyer answers. A continuous platform is relevant when those follow-up decisions are part of the requirement.

For a team that only needs to validate a new JSON-LD block before launch, start with manual source inspection and Google's test. For a team that needs recurring diagnosis across seven engines, compare the time saved on detection, fixes and measurement.

7. Recheck the result with an illustrative example

An illustrative example shows why schema validation and AI visibility checks belong in sequence. Suppose a company publishes a service page with an FAQPage block, but the live source still contains an old service name and answers copied from a previous template.

1. Inspect the live source and record the old name, duplicated answers and page URL.

2. Run the JSON-LD through a Schema.org validator and correct the entity values, property structure and answer text.

3. Run the live URL through Google's Rich Results Test and confirm that the detected type matches the page's visible FAQ content.

4. Check the canonical URL, indexability and Search Console after deployment.

5. Ask the same buyer prompt in ChatGPT, Perplexity, Gemini, Claude, Grok, Google AI Overviews and Google AI Mode before and after the change. Record whether the company is named, whether the corrected page is cited, and which competitor appears instead.

If the markup passes but the competitor remains the cited source, do not keep rewriting valid JSON-LD blindly. Compare the page's answer, evidence, internal links and external references with the cited competitor, then make the next page change that addresses the observed gap.

8. Turn the check into a repeatable change cycle

The final step is to connect every schema check to an owner, a release and an outcome. Store the original markup, test results, deployment date, affected URLs and buyer prompts so the next review can distinguish a real improvement from a temporary answer change.

Use this short operating checklist:

• Recheck live source after every template or CMS release.
• Validate vocabulary and syntax before requesting search indexing.
• Test Google eligibility for the features the page actually supports.
• Crawl related templates when one shared component changes.
• Track the same buyer prompts across all seven named engines.
• Compare mentions, citation position, cited pages and competitor appearances.
• Keep failed checks open until the corrected live URL passes again.

Cituna's free AI visibility scan is a practical next step for seeing whether the problem is only crawler readiness or whether buyer questions also show missing mentions and citations. Account signup is required, and ongoing brand mention and citation tracking requires a plan. Teams that need to act on the results can connect the findings to generated fixes rather than stopping at a validation report.

Related reading

• What Is an AI Visibility Audit? What It Checks and What You Get
• AI Brand Monitoring: How to Track What AI Says About You

Official sources to check

• Google Search Central (developers.google.com)
• Sitebulb Structured Data (sitebulb.com)

Drafted with AI assistance from our own research and Search Console data, and reviewed by Rahul A before publishing. Rules and prices change; check the linked official source before you act.