Schema Markup for SEO: A Beginner's Guide to Structured Data

The first schema markup I ever added to a client site was a single LocalBusiness block on a Kothrud dental clinic's homepage, more out of habit than expectation. The ranking did not move that week. What changed was the listing itself: opening hours and a location snippet started showing up under the blue link, and calls from that page went up before the ranking did. That clinic later climbed from position 59 to inside the top five within two months, through content and links, not through schema, but the markup was already there quietly doing its smaller job the whole time. That is the honest version of what schema markup does, and it is worth saying plainly before anything else in this guide.

This is the pillar guide I link from most of the technical posts on this site, so I have kept it broad on purpose. It covers what structured data actually is and is not, JSON-LD against the older microdata format, the eight schema types a small business in India actually needs with a copy-paste example for each, where to place the code on WordPress, Shopify, Wix and a hand-coded site, how to validate what you have added, a six-step implementation process, and the mistakes that most often trigger a warning in Search Console.

What schema markup does, and does not do, for rankings

Structured data is a shared vocabulary, maintained by Schema.org, that describes the parts of a page in a way a machine can parse directly: this block of text is a price, this one is a business address, this one is a question and its answer. You add it as code, almost always JSON-LD, and it sits alongside your normal HTML without changing how the page looks to a visitor. Google, Bing and other search engines read it to build the enhanced results you see in search: star ratings, recipe cook times, FAQ dropdowns, event dates, a breadcrumb trail in place of a raw URL.

Here is the part that gets oversold constantly. Google has said plainly that structured data is not a ranking factor in the way page speed or backlinks are. Adding FAQPage schema to a page will not move it from position eight to position three. What structured data does is make a page eligible for a rich result, and a rich result changes how a listing looks and performs at whatever position it already holds. A result with an expandable FAQ or a star rating takes up more space and reads as more trustworthy than a plain blue link sitting in the same spot, and it typically earns a meaningfully higher click-through rate for that reason. On one FAQ post on this site, the click-through rate rose 34 percent in two weeks with the ranking position unchanged. Schema does not move your position; it moves how many people click once you are there.

There is a second, newer reason structured data matters. Google's AI Overviews and other AI-generated answers pull from pages that are easy to parse cleanly, and clear structured data is one of the signals that makes a page easier to lift a fact or a step from. I go into this in more depth in my guide to how to appear in Google AI Overviews, but the short version is that FAQPage and HowTo markup give an AI system a ready-made question-and-answer pair or a numbered process it does not have to infer from prose.

JSON-LD versus microdata

Schema.org allows three formats: JSON-LD, Microdata and RDFa. You only ever need to know about the first two, and in practice only the first. JSON-LD is a block of JSON that sits inside a <script type="application/ld+json"> tag, usually in the page head, completely separate from the visible HTML. Microdata instead threads special attributes, itemscope, itemtype and itemprop, directly onto the existing HTML tags that display the content.

Google recommends JSON-LD, and every example in this guide uses it, for a practical reason more than a technical one. With JSON-LD you write one self-contained block and paste it in; the visible page does not need to change at all. With microdata you are editing the same HTML that controls how the page looks, just to add an itemprop attribute. On a WordPress site, an SEO plugin can inject a JSON-LD block without ever touching your theme's template files; try the same thing with microdata and you are usually editing the theme directly. I use JSON-LD exclusively on every site I touch, including this one, and have not needed microdata in three years of doing this professionally.

The eight schema types a small business actually needs

Schema.org lists hundreds of types and most do not apply to a small business site. These eight cover almost every page you will build: a homepage, a service or product page, a blog post, an FAQ section, a how-to guide, and the navigation trail that ties it together. Each example below is deliberately short. Copy it, replace the values with your own, and keep the structure.

1. LocalBusiness

Use this on the homepage or contact page of any business that serves customers in a specific area: a clinic, salon, restaurant, shop or agency. It carries your name, address, phone number and hours, and it feeds Google Maps, the local pack and knowledge panels alongside your Google Business Profile. If you have already worked through the basics in my technical SEO guide, LocalBusiness is usually the next thing I add.

{
  "@context": "https://schema.org",
  "@type": "LocalBusiness",
  "name": "Kothrud Dental Care",
  "telephone": "+91-98765-43210",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "12 FC Road",
    "addressLocality": "Pune",
    "addressRegion": "Maharashtra",
    "postalCode": "411004",
    "addressCountry": "IN"
  },
  "openingHours": "Mo-Sa 10:00-20:00"
}

2. Organization or Person

Use Organization for a company with multiple people behind it, and Person for a freelancer, consultant or anyone whose personal name is the brand. This site uses Person throughout, because the business is me. The two types share most of the same properties, name, url, image, contact details, so the choice comes down to whether customers are buying from a company or from an individual. Whichever you pick, keep it consistent site-wide; mixing Organization on one page and Person on another confuses the entity Google is trying to build around your brand.

{
  "@context": "https://schema.org",
  "@type": "Person",
  "name": "Shreyas Bagal",
  "url": "https://shreyasbagal.in/",
  "jobTitle": "Freelance Digital Marketer",
  "address": {
    "@type": "PostalAddress",
    "addressLocality": "Pune",
    "addressCountry": "IN"
  }
}

3. Article

Use this on blog posts and news-style pages. It carries the headline, author, publish date and modified date, and it is what makes a post eligible for Google's Top Stories carousel and for the byline sometimes shown under a search result. Keep dateModified honest; updating it without actually changing the content is a pattern Google has gotten better at noticing.

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How to Rank on Google Maps",
  "datePublished": "2026-09-01",
  "dateModified": "2026-09-14",
  "author": { "@type": "Person", "name": "Shreyas Bagal" }
}

4. FAQPage

Add this to any page with a genuine frequently-asked-questions section, meaning the questions and answers are visible in the page's own HTML, not hidden behind a click or added only for the schema. Each pair becomes eligible for an expandable dropdown directly in the search result, which can roughly double the vertical space your listing occupies. I add FAQPage to nearly every guide I publish for exactly that reason, and I go deeper on the format in FAQ schema for Google AI Overviews.

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "Do I need a website for my shop?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "Not always, but it helps you rank and look credible."
    }
  }]
}

5. HowTo

Use this for a genuine step-by-step process: a setup guide, a recipe, a repair, an onboarding checklist. Each step becomes a structured entry that search and AI systems can read as an ordered process. Google stopped showing HowTo rich results in September 2023, so treat this markup as a clarity signal, not a way to change how your listing looks. It only fits content that is actually sequential; forcing HowTo onto a page that is really a list of tips with no order is one of the mismatches that causes warnings later in this guide.

{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to Set Up a Google Business Profile",
  "step": [{
    "@type": "HowToStep",
    "name": "Claim your listing",
    "text": "Search your business on Google Maps and click Claim this business."
  }]
}

6. Product

For an individual product page on a store, never for a category or listing page that shows many products at once, which needs a different structure that I cover in schema markup for category pages. Product carries the name, image, price, availability and, where genuine, a review rating, and it is what produces the price and star rich results you see directly in search.

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Bhringraj Hair Oil 200ml",
  "image": "https://example.in/oil.jpg",
  "offers": {
    "@type": "Offer",
    "price": "349",
    "priceCurrency": "INR",
    "availability": "https://schema.org/InStock"
  }
}

7. BreadcrumbList

Tells Google the navigation path to the page: Home, then a category, then the page itself. Instead of a raw URL under your listing, Google can show a clean trail like "Home > Blog > Schema Markup Guide." Keep every URL in the list identical to that page's own canonical URL; a mismatch here creates the same kind of duplicate signal a wrong canonical tag does.

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://example.in/" },
    { "@type": "ListItem", "position": 2, "name": "Services", "item": "https://example.in/services/" }
  ]
}

8. WebSite

Add this once, sitewide, usually on the homepage. It names the site and, if you have on-site search, can include a SearchAction that makes Google eligible to show a search box directly under your homepage listing. It also gives every other page something to point back to, which is the kind of small consistency signal I check for in every crawling audit.

{
  "@context": "https://schema.org",
  "@type": "WebSite",
  "url": "https://example.in/",
  "name": "Example Business",
  "potentialAction": {
    "@type": "SearchAction",
    "target": "https://example.in/search?q={query}",
    "query-input": "required name=query"
  }
}

Where to add schema markup depending on your platform

The JSON-LD script tag is the same everywhere. What differs is where your platform lets you paste it, and whether it will quietly generate some of it for you already.

WordPress

Rank Math and Yoast SEO both generate Article, BreadcrumbList and Organization or Person schema automatically from fields you already fill in, like the featured image and the author profile. Both plugins also let you build FAQPage and HowTo blocks visually, without touching code, through their schema or FAQ block editors. For a type a plugin does not cover, most SEO plugins have a custom schema field, or a header-and-footer plugin can paste a script tag straight into the head.

Shopify

Shopify themes add Product schema on product pages and a basic Organization block automatically, though the quality varies by theme. For LocalBusiness, FAQPage or HowTo, which most themes do not generate, edit the theme's theme.liquid file and paste the script tag before the closing head tag, or use an app built for structured data if you would rather not touch the theme code directly.

Wix

Wix's SEO settings panel on paid plans lets you paste custom structured data per page under Advanced SEO, without editing the site's code. It is the most restricted of the four platforms here, workable for Article, FAQPage and LocalBusiness, but it will not let you touch sitewide template code the way WordPress or a static site does.

A static or hand-coded site

This site is a static HTML site, and every script tag in this very guide's head was typed by hand into the page's source file. If you built your site this way, or a developer did, place each <script type="application/ld+json"> block inside the head of the specific HTML file it describes. There is no plugin to do it for you, which is more work upfront and considerably easier to get exactly right, since nothing is generating markup you have not personally checked.

How to validate your schema markup

Three tools matter here, and I run all three on every page before calling the markup finished.

Google's Rich Results Test. Paste in a URL or a raw code snippet and Google shows you exactly which rich results the page qualifies for, along with any errors that will block a result and any warnings that will not block it but could be improved. This is the first tool I open after writing a new schema block, because it reflects what Google's own systems parsed, not just whether the JSON is technically valid.

The Schema Markup Validator. Hosted at validator.schema.org, this checks your code against the full Schema.org specification rather than against what Google specifically supports. It catches structural problems the Rich Results Test sometimes misses, like a property that does not belong on that type, and it is the tool I reach for when a block looks fine in the Rich Results Test but I want every property confirmed correct.

Google Search Console's Enhancements reports. The first two tools check one page at a time. Search Console's Enhancements section, under the sidebar for each schema type you have live, shows every page across the whole site with that type, split into valid, valid with warnings and invalid. This is where I catch a mistake that made it into a template and is now repeated across fifty pages instead of one, which the per-page tools cannot show you.

Run all three after any schema change, not just once at launch. A single missing comma or an extra bracket breaks the whole block, and Google does not send you an email about it. It just stops reading that script tag, silently, and the rich result you were expecting never appears.

How to add schema markup to your site in six steps

The sequence below is what I follow on every page, whether it is a new post on this site or a client's homepage. It takes under an hour once you have picked your types from the list above.

Step 1: List which schema types this page needs

Not every type belongs on every page. A blog post usually needs Article, FAQPage if it has a real FAQ section, BreadcrumbList and Person. A homepage needs LocalBusiness or Organization, WebSite and BreadcrumbList. Write the list down before writing any code; deciding this upfront is what stops you copying a block that does not actually fit the page.

Step 2: Write the JSON-LD from the examples above

Copy the example that matches each type you listed and replace every value: name, URL, address, dates, questions. Keep the structure and the property names exactly as they are; these are fixed by the Schema.org specification and cannot be renamed to whatever feels natural.

Step 3: Place the script tags in the page head

Each block goes inside its own <script type="application/ld+json"> tag, or combined into one block using a graph array if your platform makes that easier to manage. I place them in the head wherever I have access to it, because it keeps structured data separate from the visible content markup; if your platform only lets you inject code before the closing body tag, that works too, Google reads both locations.

Step 4: Test with the Rich Results Test before publishing

Paste the page's draft HTML or, once live, the URL, into the Rich Results Test. Fix every error it flags. Warnings are optional but worth clearing, since they usually point at a recommended property that would make the rich result look more complete.

Step 5: Publish, then confirm with the Schema Markup Validator

Once the page is live, run the real URL through validator.schema.org for a second, stricter check. This is also the point to view the page source directly and confirm there is exactly one of each script tag; a plugin and a manual edit both adding Article schema is a common way to end up with two competing blocks.

Step 6: Watch Search Console Enhancements for the following weeks

New markup does not show up as a rich result the moment you publish. Over the following days and weeks, check the Enhancements report for the type you added and confirm the page count climbs and the error count stays at zero. This is also how you catch a template-wide mistake before it spreads to every page built from that template.

Schema mistakes that trigger warnings

Most schema warnings come from a short list of repeatable mistakes. Here are the ones I find most often on Indian small business sites.

Markup for content that is not on the page. FAQPage schema describing questions a visitor cannot actually see anywhere in the page's HTML is the single most common cause of a manual action tied to structured data. Every type you add has to describe something real and visible on that URL.

Using deprecated or misspelled properties. Schema.org updates its specification regularly, and a property that validated two years ago can be quietly retired. Re-run older pages through the Schema Markup Validator occasionally rather than assuming markup you wrote once stays correct forever.

Broken JSON syntax. A trailing comma after the last item in an array, an unescaped quote inside a string value, a missing closing bracket. Any one of these breaks the entire script block, and unlike an HTML mistake, nothing visibly complains; the block just fails silently and Google ignores it.

Missing required properties. Every type has properties Google treats as required for a rich result and others it treats as merely recommended. Skip a required one, like image on a Product, and you get a valid parse with no rich result at all. The Rich Results Test lists exactly which properties are missing, so there is rarely a reason to guess.

Repeating identical Organization or LocalBusiness blocks with different details. I see this most often after a site redesign: the old theme's Organization schema is still hiding in a footer template while the new one lives in the head, and the two disagree on the address or phone number. Search every template for the type name before assuming there is only one instance.

Using schema instead of fixing the actual meta tags. Structured data is not a substitute for a well-written title and description. I still see pages with excellent FAQPage markup and a title tag that is just a file name. Get the basics from my meta tags guide right first, or generate them with the free meta tag generator, then layer schema on top.

Frequently asked questions

Do I need a developer to add schema markup to my website?

Not for the basics. If you use WordPress with Rank Math or Yoast, most schema types are generated automatically from settings you already fill in, like your business address or the FAQ block you add to a post. Shopify and Wix handle Product and Organization markup through their own settings pages. Where I still write JSON-LD by hand is FAQPage and HowTo, because plugins rarely expose those cleanly, and a static site like this one needs every script tag written manually. Copying one of the examples in this guide and swapping in your details takes about ten minutes, no developer required.

What happens if there's an error in my schema markup?

Google is fairly forgiving. A small error, like a missing recommended property, usually means you miss out on a rich result but the page still gets indexed normally. A bigger error, like broken JSON with a missing bracket or comma, makes Google ignore that entire script block, again without penalizing the page itself. The one case that causes real damage is markup describing content that is not actually on the page, such as FAQ schema for questions nobody can see. Run the Rich Results Test after every change and most errors get caught before they matter.

Can one page have more than one schema type?

Yes, and most pages should. A blog post on this site typically carries Article, FAQPage, BreadcrumbList and Person schema together, each in its own script tag. A product page might combine Product, BreadcrumbList and Organization. The only rule is that every type you add has to describe something that genuinely exists on that page. Stack as many accurate types as apply; there is no limit and no penalty for having several on one URL.

How long does it take for schema changes to appear in Google?

It depends on how often Google recrawls the page, not on the markup itself. For a page Google already crawls often, I have seen new markup picked up within three to five days. For a page that is crawled rarely, it can take a few weeks. Submitting the URL through Search Console's URL Inspection tool and requesting indexing after a schema change usually speeds this up. Rich results are also not guaranteed even once Google reads the markup correctly; eligibility is not the same as display.

Is schema markup still worth doing if Google says it's not a ranking factor?

Yes. Google is telling the truth when it says structured data does not move your position in the results directly, but position is not the only thing that decides how much traffic a page gets. A listing with a star rating, an FAQ dropdown or a how-to preview takes up more space and reads as more trustworthy than a plain blue link sitting in the same spot. On one FAQ post on this site, the click-through rate rose 34 percent in two weeks with no change in ranking position at all. Schema markup earns more clicks from the ranking you already have.

Related guides

• Entity SEO: Meaning, Examples and How to Build Your Entity
• LocalBusiness Schema Markup: JSON-LD Examples and Setup
• Schema markup for category pages: what belongs on a listing page instead of Product or Article.
• FAQ schema for Google AI Overviews: how to write FAQ schema that gets your content cited in AI-generated answers.
• What is a canonical URL?: why your BreadcrumbList and canonical URLs need to agree.
• What is crawling in SEO?: how Googlebot discovers and revisits the pages you mark up.
• Technical SEO basics for business owners: the broader foundation schema markup sits on top of.
• Free on-page SEO checklist (2026): a step-by-step checklist covering every on-page element, schema included.

Your next step

Pick one page, most likely your homepage or your best-performing blog post, and add the two or three schema types that actually fit it using the examples above. Validate with the Rich Results Test, publish, and check back in Search Console in a couple of weeks. Once your structured data is in order, run the page through my on-page SEO checklist for 2026 or the free website SEO checker to see what else is worth fixing before you move to the next page.