Schema Markup Guide for Small Businesses 2026

The Schema Markup Handbook for Small Businesses

Schema markup is one of the most underused SEO advantages available to small businesses. While your competitors write standard web pages, schema gives Google richer, more precise information about your content — enabling search features like star ratings, opening hours, FAQ dropdowns, and event listings to appear directly in search results before anyone clicks.

The word "schema" puts many business owners off. It sounds technical. It involves code. But the reality is that implementing the most impactful schema types for a small business website can be done in an afternoon, requires no ongoing maintenance once set up, and can measurably improve your click-through rates from search results.

This handbook covers everything from the fundamental concepts through to step-by-step implementation guides for the schema types that matter most.

Key Takeaways

Schema markup is published vocabulary from Schema.org, a collaborative project backed by Google, Bing, Yahoo, and Yandex
JSON-LD (JavaScript Object Notation for Linked Data) is Google's recommended format for implementing schema — it is the simplest and safest approach
LocalBusiness schema is the single highest-priority schema type for small businesses — it communicates your name, address, opening hours, and contact details in a machine-readable format
FAQPage schema can add expandable Q&A entries below your listing in search results, doubling or tripling the space your result occupies
Google's Rich Results Test is the definitive tool for validating your implementation
Schema markup does not guarantee rich results — it makes you eligible for them. Google decides whether to display them based on quality signals and query context

What Schema Markup Actually Is

The Problem Schema Solves

Web pages are written for humans. When you describe your business as "a friendly family-run plumbing company serving Bristol and the surrounding area," a human reader understands that perfectly. But Google's algorithms read those same words and have to infer meaning — that you are a plumber, that you are based in Bristol, that you are locally focused.

Schema markup speaks directly to search engines in their own language. Instead of inferring that you are a plumber in Bristol, you tell Google explicitly: "@type": "Plumber", "addressLocality": "Bristol". This precision helps Google understand, categorise, and display your content more accurately.

Schema.org: The Shared Vocabulary

Schema.org is an open vocabulary — a shared set of definitions for the types of things that appear on the web (businesses, people, products, events, articles, recipes, and hundreds more). The vocabulary is maintained by a community and backed by all the major search engines.

When you implement schema, you are using this shared vocabulary to annotate your content. You are saying: "This part of my page describes a LocalBusiness. It has a name, a telephone, an openingHoursSpecification, and a priceRange." Google recognises these terms and can use them to enhance how your listing appears in search results.

What Schema Can Do for Your Listings

Correctly implemented schema makes you eligible for Google's enhanced search features, known as rich results. Examples include:

Star ratings in search listings (requires aggregateRating schema with review data)
FAQ dropdowns below your search listing that users can expand without clicking (requires FAQPage schema)
Opening hours displayed directly in local search results
Product price and availability shown in product search results
Event dates and times in event listings
Article publication dates and author information

These features take up more space in search results, draw the eye, and typically improve click-through rates. Google's own structured data gallery shows every rich result type available.

JSON-LD vs Microdata: What to Use

There are three ways to add schema markup to a web page: JSON-LD, Microdata, and RDFa. For almost all small business use cases, JSON-LD is the right choice, and it is what Google recommends.

JSON-LD (JavaScript Object Notation for Linked Data) is a block of code placed in the <head> or <body> of your page inside a <script type="application/ld+json"> tag. It is entirely separate from your visible HTML — adding it does not change how your page looks or how the existing code works. It is easy to add, easy to update, and easy to validate.

Microdata embeds schema attributes directly into your HTML elements. It is more complex to implement and maintain, and a mistake in one place can break the markup for the entire entity.

RDFa is similar to Microdata but uses a different syntax. Unless you have a specific technical reason to use it, ignore it for small business purposes.

The rest of this guide assumes you are using JSON-LD.

Essential Schema Types for Small Businesses

LocalBusiness Schema

If you implement only one schema type, make it LocalBusiness. This is the foundational schema for any business with a physical presence or a service area, and it directly feeds Google's local search features.

LocalBusiness is actually a parent type with many specific subtypes. Wherever possible, use the most specific type that accurately describes your business. Examples:

Plumber → Plumber
Restaurant → Restaurant
Dentist → Dentist
Solicitor → LegalService
Estate agent → RealEstateAgent
Hair salon → HairSalon
Accountant → AccountingService

The full list of LocalBusiness subtypes is at Schema.org.

Essential fields to include:

{
  "@context": "https://schema.org",
  "@type": "Plumber",
  "name": "Bristol Plumbing Solutions",
  "url": "https://www.bristolplumbingsolutions.co.uk",
  "telephone": "+44-117-123-4567",
  "email": "hello@bristolplumbingsolutions.co.uk",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "24 Harbour Road",
    "addressLocality": "Bristol",
    "postalCode": "BS1 4RB",
    "addressCountry": "GB"
  },
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": 51.4545,
    "longitude": -2.5879
  },
  "openingHoursSpecification": [
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
      "opens": "08:00",
      "closes": "18:00"
    },
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": "Saturday",
      "opens": "09:00",
      "closes": "13:00"
    }
  ],
  "priceRange": "££",
  "description": "Emergency and planned plumbing services across Bristol and North Somerset. Available 24/7 for urgent callouts.",
  "areaServed": ["Bristol", "North Somerset", "South Gloucestershire"]
}

Place this code block in the <head> of every page on your site (or at minimum your homepage and contact page). The information should match exactly what is on your Google Business Profile.

Organisation Schema

Organization schema is broader than LocalBusiness — it defines your business as a legal entity rather than a physical location. Use it on your homepage and "About" page to define your brand, social profiles, and contact information at an organisational level.

Key fields: name, url, logo, sameAs (array of your social media profile URLs and Companies House URL), contactPoint.

The sameAs field is particularly valuable — it connects your website to your verified profiles across the web, helping Google build a confident entity understanding of your business.

Product Schema

For businesses selling products (either e-commerce or physical goods), Product schema enables rich results including price, availability, and review ratings. We cover this in depth in our E-commerce SEO guide.

Key fields: name, description, image, brand, offers (with price, priceCurrency, availability), aggregateRating.

Frequently Asked QuestionsPage Schema

FAQPage schema is one of the highest-impact schema types for small businesses because it can dramatically increase the space your listing occupies in search results. When Google displays your FAQ rich result, expandable Q&A entries appear below your standard listing — potentially showing 2–4 Q&A pairs without the user clicking.

This schema is appropriate for any page that contains a genuine FAQ section. Important: the questions and answers must be visible to users on the page — do not implement FAQPage schema for content that is hidden or not present in the HTML.

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How quickly can you respond to an emergency plumbing call?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "We aim to reach emergency callouts within 60 minutes across Bristol. For urgent issues such as burst pipes or no hot water, call us directly on 0117 123 4567 — we operate 24 hours a day, 7 days a week."
      }
    },
    {
      "@type": "Question",
      "name": "Are your plumbers Gas Safe registered?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes, all our engineers are Gas Safe registered (registration number: XXXXXX). We can provide certification on request. You can verify our registration on the official Gas Safe Register website."
      }
    }
  ]
}

BreadcrumbList Schema

Breadcrumb schema defines the hierarchy of the current page within your site structure. When implemented correctly, Google displays these breadcrumbs in search results instead of the raw URL — making your listing look more organised and user-friendly.

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://www.bristolplumbingsolutions.co.uk"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Services",
      "item": "https://www.bristolplumbingsolutions.co.uk/services"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Boiler Servicing",
      "item": "https://www.bristolplumbingsolutions.co.uk/services/boiler-servicing"
    }
  ]
}

Article Schema

For blog posts and news articles, Article (or the more specific subtypes NewsArticle and BlogPosting) schema communicates authorship, publication date, and content type to Google. This is particularly important for E-E-A-T: connecting your content to a named, credible author is a trust signal.

Key fields: headline, author (with name and optionally url), datePublished, dateModified, publisher (with name and logo), image.

Step-by-Step Implementation Guide

Step 1: Identify Your Priority Pages

Start with your most important pages: homepage, primary service/product pages, contact page. Do not try to implement schema across your entire site at once — start with what will have the most impact.

For each page, identify which schema type is most relevant:

Homepage: LocalBusiness + Organization + potentially FAQPage if there is an FAQ section
Service pages: Service schema + FAQPage if there are FAQs
Product pages: Product schema with offers and aggregateRating
Blog posts: BlogPosting or Article schema
All pages: BreadcrumbList schema

Step 2: Write Your JSON-LD

Use Google's Structured Data Markup Helper to generate JSON-LD interactively, or write it manually following the examples in this guide and the Schema.org documentation.

Step 3: Add the Code to Your Page

Paste the JSON-LD block inside a <script type="application/ld+json"> tag. It can go in the <head> or anywhere in the <body> — both work. For CMS platforms:

WordPress: Use a plugin like Schema Pro, Rank Math, or Yoast SEO Premium, or add code directly via functions.php or a header/footer plugin
Shopify: Add JSON-LD to your theme's theme.liquid file, or use a schema app
Squarespace / Wix: Use the custom code injection feature (available on paid plans)
Static HTML: Add directly to the page's <head>

Step 4: Validate Your Implementation

Go to Google's Rich Results Test, enter your page URL, and run the test. The tool will show you:

Which schema types it detected
Which rich results you are eligible for
Any errors or warnings in your markup

Fix any errors before moving on. Warnings are usually not critical but are worth addressing where possible.

Step 5: Monitor in Google Search Console

After deploying your schema and allowing a few days for Google to recrawl your pages, check Search Console under "Enhancements" — you will find reports for each schema type (FAQ, Breadcrumbs, Products, etc.) showing how many pages have valid schema and whether any errors were detected.

Testing and Debugging Schema

Getting schema into your page's HTML is only half the job. In our experience, a significant proportion of schema implementations contain errors that prevent rich results from appearing — missing required fields, type mismatches, schema describing content that is not visible on the page, or conflicts between automatically generated schema and manually added blocks. Methodical testing catches these before they become invisible problems.

Google's Rich Results Test

The Rich Results Test (search.google.com/test/rich-results) is the authoritative tool for validating schema and the one you should use first. Enter either a live URL or paste raw HTML, and the tool will:

Detect all schema types present on the page
Tell you which rich result features you are eligible for (e.g. FAQ snippet, star ratings, breadcrumbs)
Flag errors that prevent rich results from appearing
Flag warnings that may reduce your eligibility

Errors must be fixed — they represent broken or missing required properties. Warnings are advisory; they typically involve recommended but non-required fields. In practice, fixing warnings usually improves the quality of your schema even if they do not block rich results outright.

One important nuance: the Rich Results Test evaluates your page as Googlebot sees it, which includes JavaScript rendering. This means it catches errors that a simple source-code inspection would miss, such as schema injected by a CMS plugin that renders incorrectly on certain page types.

Schema Markup Validator

The Schema Markup Validator (validator.schema.org) is a complementary tool that validates schema against the Schema.org specification rather than specifically against Google's rich result requirements. Use it when you want to check whether your markup is structurally correct even for schema types that Google does not surface as rich results.

In practice, run both tools. The Rich Results Test tells you whether you will get Google's enhanced search features. The Schema Markup Validator tells you whether your markup is logically correct — useful for catching type mismatches and property errors that the Rich Results Test might overlook for less common schema types.

Common Validation Errors and How to Fix Them

Missing required field: The Rich Results Test will name the specific field. For Product schema, common missing fields are offers (required for price display) and name. For LocalBusiness, address is frequently absent or incorrectly structured. Add the missing field and re-run the test.

Wrong property type: Schema properties expect specific data types. telephone expects a string formatted as a phone number; geo expects a GeoCoordinates object, not a plain text address. If you see a type error, check the Schema.org documentation for the expected format.

Schema describing content not visible on the page: FAQPage schema must match questions and answers that are actually rendered in the page's HTML. If your FAQ section is loaded via JavaScript and the Rich Results Test is run in "fetch as URL" mode without JS rendering, it may not detect the content. Use the URL-based test (not the code snippet test) to ensure full rendering.

Duplicate schema blocks: If your CMS (Yoast, Rank Math, or your theme) generates schema automatically and you also add schema manually, you can end up with two LocalBusiness definitions on the same page. Google may process both, leading to conflicting signals. View your page source (Ctrl+U in Chrome) and search for application/ld+json — count how many blocks exist and ensure they do not conflict.

Mismatched data between schema and page content: Your schema must describe what is actually on the page. If your LocalBusiness schema lists Monday–Saturday hours but your contact page says Monday–Friday, this is a mismatch. Google may flag it, and it creates a poor experience for customers who act on the schema data shown in search results. Treat your schema as a contract: if it says something, the page must confirm it.

Checking Deployed Schema in Production

After deploying, verify that your schema is live and correct on the actual production URL — not just in a test environment. CMS caching, CDN behaviour, and plugin conflicts can mean that schema visible in your development environment does not appear correctly in production.

The simplest check: open your live page URL in Chrome, right-click, and select "View Page Source." Search (Ctrl+F) for application/ld+json to find every schema block on the page. Paste each block into the Schema Markup Validator to verify it validates cleanly.

For sites with many pages (e-commerce catalogues, multi-location business sites), manual checking does not scale. In this case, use Search Console's Enhancement reports as your monitoring layer. Set up a weekly check of the Enhancements section — any new errors flagged there need prompt attention. Google can take 2–4 weeks after a schema issue appears to surface it in Search Console, so errors you fix today may not clear from the report immediately.

Schema for Different Business Types

For Restaurants and Cafes

Key additional schema types: Menu or hasMenu property, servesCuisine, acceptsReservations, and aggregateRating. Including your menu URL in schema helps Google surface your menu in local Knowledge Panel results.

For Healthcare Providers

Physician, Dentist, MedicalClinic subtypes include fields for medicalSpecialty, availableService, and isAcceptingNewPatients. These display in Google's healthcare-specific search features.

For Service Businesses (Trades, Cleaners, etc.)

The Service schema type (with provider, serviceType, areaServed) can be implemented on individual service pages. Combine with LocalBusiness on your homepage and FAQPage on service-specific FAQ content.

For Events Businesses

Event schema (name, startDate, endDate, location, organizer, offers) enables Google Events rich results — your events can appear in the dedicated events carousel in search results, which often attracts high click-through rates.

Common Schema Mistakes

Using the wrong type: Implementing generic Organization schema when LocalBusiness (or a specific subtype) is more accurate. Always use the most specific type that genuinely applies.

Mismatching schema data and page content: Your schema should describe what is actually on the page. If your schema says you are open Monday–Saturday but your page says Monday–Friday, this is a mismatch Google may flag.

Implementing schema for hidden content: FAQPage schema must describe questions and answers that are visible to users on the page. Schema for content hidden behind JavaScript modals or display:none CSS may not be processed.

Multiple conflicting schema blocks: If your CMS automatically generates schema (Yoast, for example) and you also manually add schema, you may end up with duplicated or conflicting definitions. Check your page source to confirm you have only one definition per schema type.

Ignoring errors in Rich Results Test: Errors in your schema markup will prevent rich results from appearing. Run the test on your key pages and fix any reported errors.

Frequently Asked Questions

Does schema markup directly improve my Google rankings?

Not directly — schema is not a confirmed ranking factor. However, it makes you eligible for rich results that improve click-through rates, and higher CTR is a positive user engagement signal. Better CTR → more traffic → more engagement signals → indirectly supports rankings over time.

How often do I need to update my schema?

Update it whenever the underlying information changes: new opening hours, new phone number, new address, new services. Set a calendar reminder to review your schema every six months alongside your other local SEO maintenance.

Do I need a developer to implement schema?

Not necessarily. If you use WordPress with Yoast or Rank Math, these plugins handle much of the schema automatically and allow you to add custom schema through their interfaces. For Shopify, apps like Schema Plus or JSON-LD for SEO handle implementation without code. Basic JSON-LD can also be added to most CMS header sections without developer help.

My website already has schema — do I need to do anything?

Run the Rich Results Test and check for errors. Many CMS-generated schema implementations have common mistakes — missing required fields, incorrect types, or outdated information. Verify it is working correctly even if something is technically in place.

Can I implement multiple schema types on one page?

Absolutely. It is normal and correct to have LocalBusiness + BreadcrumbList + FAQPage all on the same page in separate <script type="application/ld+json"> blocks, or combined into a single block using the @graph property.

Monitor Your SEO Performance

Understanding whether your technical improvements — including schema markup — are driving real ranking and traffic results is essential. RnkRocket's rank tracking and site intelligence tools give you clear visibility into what is working and where to focus next.

See pricing and start tracking your results