Schema Markup for Beginners: Get Rich Results in Google

Schema markup is a small block of code that tells search engines exactly what a page is about: who runs the business, what a product costs, when an article was published, and who wrote it. This beginner tutorial explains the core concepts, shows which schema types are worth your time in 2026, gives you copy-and-adapt JSON-LD examples, and walks through validation so your pages have a genuine shot at rich results in Google.

Quick answer: Schema markup is structured data, written with the Schema.org vocabulary, that labels the facts on a page so search engines can read them reliably. Google recommends the JSON-LD format. Add markup that matches visible content, test it in the Rich Results Test, and monitor Search Console. Markup makes pages eligible for rich results, but never guarantees them.

What is schema markup?

Schema markup is code that describes the things on a web page (businesses, people, products, articles, events, recipes) using a standardized vocabulary that search engines agree on. Without it, a crawler reads your page as text and has to infer meaning. With it, you state the facts directly: “this string is the business name, this number is the price, this date is when the article was last updated.”

The vocabulary lives at Schema.org, a collaborative project launched in 2011 by major search engines. It defines hundreds of types (such as Organization, Product or Event) and the properties each type can have (such as name, price or startDate).

Structured data, schema markup and rich results: what is the difference?

Beginners often use these terms interchangeably, but they mean different things:

• Structured data is the general idea of organizing information in a predictable, machine-readable format.
• Schema.org is the specific vocabulary most websites use for that structured data.
• JSON-LD, Microdata and RDFa are the syntaxes (formats) you can use to write it.
• Rich results are the enhanced search listings Google may show when it understands your structured data, such as star ratings, prices, breadcrumbs or event dates.

A useful mental model is a moving box. The contents are your page. Structured data is the label on the outside. Schema.org is the agreed labeling system, so the movers in every city know that “FRAGILE – KITCHEN” means the same thing. Rich results are the movers deciding to give your box special handling because the label was clear and accurate.

Why does schema markup matter for SEO in 2026?

Schema markup matters because it removes guesswork about your content, and that clarity is what makes enhanced search features possible. Google does not describe structured data as a shortcut to higher rankings. According to Google Search Central, its documented role is helping Google understand the page and making it eligible for rich results.

Here is what that clarity can do for a business:

• Richer listings. Product pages can show price, availability and review stars. Event pages can show dates and locations. Recipes can show cooking time and ratings. These listings take up more space and give searchers more reasons to click.
• Cleaner business identity. Organization and LocalBusiness markup help Google connect your name, logo, address, phone number and social profiles, which reduces confusion with similarly named companies.
• Better consistency across systems. Machine-readable facts are useful wherever software reads your website. If you are exploring generative engine optimization, clean structured data is part of a sensible foundation, although no search engine promises that markup alone will get your content quoted in an AI answer.
• Stronger trust signals. Marking up authors, publishers and dates supports the transparency work described in our guide to E-E-A-T signals. It does not replace real expertise, but it makes your credentials easier to find.

How does schema markup work? The three formats

Schema markup works by embedding labeled data in your page’s HTML in one of three formats. All three use the same Schema.org vocabulary; they differ only in how the code is written and where it lives.

Google Search Central states that it recommends JSON-LD when your setup allows it, because it is the easiest option to implement and maintain at scale. The practical reason is simple: JSON-LD keeps the data in one place. A designer can rebuild the layout without accidentally deleting the markup, and a developer can update it without touching visible content.

Which schema types should beginners use?

Beginners should start with the schema types that match their most important page templates, not with every type available. The table below summarizes the most common types and what they can do in Google as of October 2026. Google’s own search gallery is the source of truth, and it changes, so check it before any big rollout.

Notice the last two rows. Both were popular for years, and many old tutorials still recommend them. Google’s documentation history shows HowTo rich results were retired in 2023, and a deprecation notice published on Google Search Central states that FAQ rich results no longer appear in Google Search starting May 7, 2026. This is the best argument for checking current documentation rather than copying a checklist from a few years ago.

Five rules to follow before you write any code

Following a few ground rules prevents most of the problems beginners run into. These come straight from the spirit of Google’s structured data guidelines.

1. Mark up only what is visible. If your page does not show a price, do not put a price in the markup. If there are no reviews on the page, do not add a rating.
2. Use the most specific type available. Dentist tells Google more than LocalBusiness, and BlogPosting tells it more than CreativeWork.
3. Keep one source of truth. Your business name, address and phone number should match your website footer, your Google Business Profile and your markup exactly.
4. Use full, absolute URLs. Write https://www.example.com/logo.png, not /logo.png.
5. Keep it current. When prices, opening hours or authors change, the markup must change too. Template-driven markup that pulls from your database is far easier to maintain than hand-typed blocks.

Tutorial: JSON-LD schema markup examples you can adapt

The five examples below are templates for hypothetical businesses. Replace every value with your own real details, delete properties you cannot fill honestly, and test each one before publishing.

Where does JSON-LD go on the page?

JSON-LD goes inside a script tag with the type application/ld+json, placed in the page’s head or body. Google can also read JSON-LD that is injected by JavaScript or by a content management system widget, although server-rendered markup is easier to debug. Here is the wrapper every example uses:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "TypeName"
}
</script>

@context tells the reader which vocabulary you are using. @type names the kind of thing you are describing. Everything else is a property of that thing. In the remaining examples, only the JSON is shown; wrap it in the same script tag.

Example 1: Organization schema

Organization markup belongs on your homepage or About page. Google’s Organization documentation lists no strictly required properties, but name, URL and logo are the essentials, and sameAs links connect your official profiles.

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Example Studio",
  "url": "https://www.example.com/",
  "logo": "https://www.example.com/images/logo.png",
  "email": "hello@example.com",
  "telephone": "+1-555-010-0100",
  "sameAs": [
    "https://www.linkedin.com/company/example-studio",
    "https://www.instagram.com/examplestudio"
  ]
}

Use a logo image that is crawlable and looks good on a white background. List only profiles you control.

Example 2: LocalBusiness schema

LocalBusiness markup describes a physical business that customers visit or that serves a defined area. Example: a hypothetical neighborhood bakery. Because Bakery is a Schema.org subtype of LocalBusiness, we use it instead of the generic type. Google lists name and address as required for local business structured data.

{
  "@context": "https://schema.org",
  "@type": "Bakery",
  "name": "Northside Bakery",
  "image": "https://www.example.com/images/storefront.jpg",
  "url": "https://www.example.com/",
  "telephone": "+1-555-010-0199",
  "priceRange": "$$",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "120 Market Street",
    "addressLocality": "Springfield",
    "addressRegion": "IL",
    "postalCode": "62701",
    "addressCountry": "US"
  },
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": 39.7990,
    "longitude": -89.6440
  },
  "openingHoursSpecification": [
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
      "opens": "07:00",
      "closes": "18:00"
    },
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": "Saturday",
      "opens": "08:00",
      "closes": "14:00"
    }
  ]
}

If you have several locations, give each one its own page with its own LocalBusiness block. Markup works best alongside the rest of your local work, so pair it with our local SEO checklist.

Example 3: Article schema

Article markup helps Google understand the headline, author, images and dates of editorial content. Google’s Article documentation has no required properties, but it recommends author, dates, headline and image. Use BlogPosting for blog posts and NewsArticle for news.

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "How to Choose a Wedding Cake Flavor",
  "image": [
    "https://www.example.com/images/cake-1x1.jpg",
    "https://www.example.com/images/cake-16x9.jpg"
  ],
  "datePublished": "2026-09-14T09:00:00-05:00",
  "dateModified": "2026-10-02T11:30:00-05:00",
  "author": {
    "@type": "Person",
    "name": "Jordan Lee",
    "url": "https://www.example.com/team/jordan-lee"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Northside Bakery",
    "logo": {
      "@type": "ImageObject",
      "url": "https://www.example.com/images/logo.png"
    }
  }
}

Dates must use the ISO 8601 format shown above. Only update dateModified when you make a meaningful change to the content, not when you fix a typo.

Example 4: FAQPage schema

FAQPage markup labels a list of questions and answers written by the site owner. Google no longer displays FAQ rich results, so treat this as optional. Some teams keep it because it accurately describes the page structure, and it causes no harm when it matches visible content.

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Do you make gluten-free cakes?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. We bake gluten-free sponge cakes to order with three days' notice."
      }
    },
    {
      "@type": "Question",
      "name": "Do you deliver?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "We deliver within 10 miles of the shop on weekdays."
      }
    }
  ]
}

Do not use FAQPage for user-submitted questions with multiple answers; that is what QAPage is for.

Example 5: Product schema

Product markup describes an item for sale. Google’s product snippet documentation requires name plus at least one of offers, review or aggregateRating. Online stores should also read Google’s merchant listing guidance, which asks for more detail about price, shipping and returns.

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Sourdough Starter Kit",
  "image": "https://www.example.com/images/starter-kit.jpg",
  "description": "Everything you need to grow and maintain a sourdough starter at home.",
  "sku": "NSB-STK-01",
  "brand": {
    "@type": "Brand",
    "name": "Northside Bakery"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://www.example.com/shop/sourdough-starter-kit",
    "priceCurrency": "USD",
    "price": "29.00",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "reviewCount": "38"
  }
}

Include aggregateRating only if the page shows genuine customer reviews that add up to those numbers. Prices are plain numbers without currency symbols, and the currency goes in priceCurrency. For the wider picture on store pages, see our guide to ranking product and category pages.

Can you combine several schema types on one page?

Yes, you can include several schema types on one page, either as separate script blocks or inside a single @graph array. A product page might carry Product, BreadcrumbList and Organization markup together. The rule is that each block must describe something actually present on that page. Avoid two plugins outputting two different versions of the same entity, because conflicting values confuse parsers.

How do you add schema markup without editing code?

Most business websites can add schema markup through their platform instead of writing it by hand. The right route depends on how your site is built, which is one of many differences we cover in Webflow vs WordPress vs custom code.

• WordPress: popular SEO plugins such as Yoast SEO and Rank Math output Organization, Article and breadcrumb markup automatically, and let you adjust settings without code.
• Shopify: many themes output basic Product markup out of the box. Inspect a product page in the Rich Results Test to see what yours includes before adding an app.
• Webflow and similar builders: paste JSON-LD into page-level custom code settings, and use CMS fields to fill values dynamically on collection templates.
• Custom-built sites: have your developer generate markup from the same database that renders the page, so prices and hours never drift out of sync.
• Google Tag Manager: possible, since Google can process injected JSON-LD, but harder to audit. Treat it as a stopgap rather than a long-term home.

How to validate schema markup: step by step

Validating schema markup means checking that the code is syntactically correct, uses real Schema.org properties, and meets Google’s requirements for the rich result you want. Follow these steps for every template you mark up.

1. Run the Rich Results Test. Paste a live URL or a code snippet into Google’s Rich Results Test. It shows which rich result types Google detected, plus any errors (which block eligibility) and warnings (which are optional improvements).
2. Run the Schema Markup Validator. The Schema.org validator checks your code against the full vocabulary, not just Google-supported features. It is useful for types Google does not display as rich results.
3. Inspect the live URL in Search Console. After publishing, use the URL Inspection tool to test the live page and confirm Google sees the markup in the rendered HTML.
4. Monitor the rich result reports. Search Console groups structured data into reports by type, with valid items, items with warnings, and invalid items. After fixing an issue, use the validate fix option so Google rechecks the affected pages.
5. Spot-check search results over time. Google decides whether to show a rich result for each query. Valid markup is a ticket to the lottery, not the prize itself.

If you are running a broader site health review, add these checks to your technical SEO audit so structured data gets tested alongside crawling, indexing and speed.

What are the most common schema markup errors?

The most common schema markup errors are missing required properties, badly formatted values, and markup that does not match the visible page. The table below covers what beginners hit most often and how to fix each one.

Why do warnings appear even when the markup is valid?

Warnings appear when you have left out recommended, not required, properties. They do not block eligibility. Fill them in when you have accurate data, and ignore them when you do not, because inventing values to silence a warning creates a bigger problem.

Can schema markup get a site penalized?

Schema markup can lead to a manual action if Google judges it misleading, for example marking up hidden content or fabricating reviews. Google’s Search Console includes a manual action specifically for structured data issues. The fix is to remove or correct the offending markup and request a review.

How long does it take for rich results to appear?

Rich results can only appear after Google recrawls the page and processes the new markup. Google Search Central notes that crawling can take anywhere from a few days to a few weeks, and requesting a recrawl repeatedly does not speed it up. Even after processing, Google may choose not to show a rich result for a given query.

If you are tracking whether markup helps, compare impressions and click-through rate in the Search Console performance report before and after deployment, and filter by search appearance where Google offers it. Give it several weeks before drawing conclusions, and remember that seasonality and ranking changes affect the same numbers. Structured data also complements content quality rather than replacing it; our playbook on earning citations in Google AI Overviews explains how clear page structure and direct answers work together.

Keep reading

Technical SEOCore Web Vitals 2026: How to Pass LCP, INP and CLSRead articleTechnical SEOTechnical SEO Audit Checklist: 25 Points to Check YourselfRead articleTechnical SEOWhy Is My Website Not Showing on Google? 10 FixesRead article