What is schema markup?
Schema markup is structured data, written in a shared vocabulary called schema.org, that labels what a piece of content actually is rather than leaving a search engine or AI system to guess from the surrounding text. A paragraph of text says a price and a rating out loud; a Product schema block says explicitly which number is the price and which is the rating, so a machine can extract them with certainty.
Google, Bing, and every major AI answer engine parse this vocabulary. Getting it right is table stakes for rich results in classic search and for showing up correctly in AI Overviews, ChatGPT and Perplexity answers, where structured data is often the cleanest signal a page has to offer.
How this schema markup generator works
- Pick the schema type that matches your page: a blog post is Article, a pricing FAQ is FAQPage, a feature or docs page is SoftwareApplication, and so on.
- Fill in the fields. Defaults are pre-filled so you can see valid, complete JSON-LD immediately, then overwrite them with your own data.
- Copy the whole script block and paste it into your page's
<head>. Google's own guidance confirms the<body>works too, but the head is the more common convention and where most CMS "custom code" fields expect it. - Validate with Google's Rich Results Test before you publish, and again any time the underlying content changes, since schema that drifts out of sync with the page is worse than no schema at all.
Which schema type should you use?
| Page type | Schema type |
|---|---|
| Blog post, guide, or news update | Article / BlogPosting / NewsArticle |
| Pricing page or support FAQ | FAQPage |
| Step-by-step guide or tutorial | HowTo |
| Product or feature page for a SaaS product | SoftwareApplication |
| About page or brand-level facts | Organization |
| Office, agency, or physical location page | LocalBusiness |
| Testimonial or case-study page | Review |
| Any page inside a category hierarchy | BreadcrumbList |
JSON-LD is the format every major search and AI engine recommends over the older Microdata and RDFa syntaxes, since it sits in a single script block instead of being woven through the visible HTML, which makes it far less likely to break when a page gets redesigned.
Common schema markup mistakes to avoid
Marking Up Content That Isn't Visible on the Page
Schema is supposed to describe what a visitor actually sees, not what you wish the page said. Adding a FAQPage block for questions that don't appear anywhere in the rendered content, or a rating that isn't shown to users, violates Google's structured data guidelines directly and can trigger a manual action that suppresses rich results sitewide, not just on the offending page. Before publishing schema, check that every field, the headline, the price, the rating, the review text, has a visible counterpart on the page a human can read.
Missing Required Properties for Rich Results
Every schema type has a shortlist of properties Google treats as required for that type to be eligible for a rich result, and a missing one is a silent failure rather than an error message: the page still has valid JSON-LD, it just never qualifies for the enhanced display. Review schema without a ratingValue, or Product schema without a price, are common examples that pass basic JSON validation while failing rich-result eligibility. Running the code through Google's Rich Results Test catches this before it ships, which is why that step belongs in the workflow every time, not just on the first page you mark up.
Stacking Duplicate or Conflicting Types on One Page
- Two Article blocks on one URL confuses more than it helps. If a template accidentally injects schema twice, once from a plugin and once from custom code, Google has to guess which one is authoritative and may ignore both.
- Conflicting facts across schema and visible text are treated as a trust signal, and a negative one. A phone number in your LocalBusiness schema that doesn't match the number printed on the page reads as low-quality or manipulative data to both search engines and AI systems.
- Check your rendered HTML, not just your CMS field, after any template change. A theme update or plugin conflict is the most common cause of an unnoticed duplicate schema block.
Publishing Without Validating First
Hand-written JSON is easy to get subtly wrong: a missing comma breaks the entire block, a misspelled property name like ratingVaule is silently ignored rather than flagged, and a nested object with the wrong @type can pass as syntactically valid JSON while being semantically useless to Google. Running new schema through the Rich Results Test takes under a minute and catches all three categories of error before they reach production, where a broken script tag can sit unnoticed for months since nothing about it causes a visible page error.
Letting Schema Go Stale After a Content Update
Schema does not update itself when you edit the page around it. A price change, a new author, an updated review count, or a revised FAQ answer all need the matching schema field touched at the same time, and most CMS setups don't enforce that link. Stale schema that contradicts the current page content is exactly the kind of mismatch Google's guidelines call out as a trust problem, so treat schema as part of the content, reviewed on every meaningful edit, not a one-time setup task you configure once and forget.
Frequently asked questions
What is the easiest way to add schema markup to a website?
Use a generator like this one: pick the schema type that matches your page, fill in the fields, and copy the JSON-LD script block it produces into your page's head. That avoids hand-writing nested objects and typos in property names, which is where most manually-written schema breaks.
Where do I paste JSON-LD schema code, in the head or the body?
The head is the standard convention and where most CMS platforms expect it, but Google's own documentation confirms JSON-LD is valid in the body too. What matters is that the script tag renders in the final HTML the page serves; if it only appears after client-side JavaScript runs, some crawlers may not see it.
How do I check if my schema markup is working?
Paste your page URL or the raw code into Google's Rich Results Test at search.google.com/test/rich-results. It flags missing required properties and shows which rich result types, if any, your markup is eligible for. Recheck after any content update, since schema drifts out of sync with the page more often than people expect.
Does adding schema markup guarantee rich results in Google?
No. Valid schema makes a page eligible for a rich result, like an FAQ dropdown or a star rating, but Google decides case by case whether to actually show one, and can stop at any time even for previously-eligible pages. Schema is also read by AI systems like ChatGPT and Google's AI Overviews as a structured summary of the page, independent of whether Google Search renders a rich result at all.