Schema Markup for Local Businesses: A Practical Guide

Your website tells human visitors what you do through words and design. Google reads the same page and has to infer everything — that “Call (555) 200-1234” is a phone number, that “Mon–Fri 8–6” is your opening hours, that the five stars near the top are customer reviews.

It’s quite good at guessing. But guessing is still guessing, and Google acts more confidently on facts it’s been told directly.

Schema markup is how you tell it directly.

What structured data actually is

Schema markup is a block of machine-readable data added to your page describing what’s on it. Visitors never see it. Search engines read it and use it to understand your business with certainty rather than inference.

The vocabulary is defined at schema.org, a standard maintained collaboratively by Google, Microsoft, Yahoo, and Yandex. Because all the major engines agreed on it, markup written once works everywhere.

Here’s a stripped-down example:

{
  "@context": "https://schema.org",
  "@type": "Plumber",
  "name": "RapidFlow Plumbing",
  "telephone": "+15552001234",
  "url": "https://example.com",
  "areaServed": "Austin, TX"
}

That’s it. A short block stating plainly: this is a plumbing business, here’s the phone number, here’s where it operates.

What it actually does for you

Let’s be precise, because schema gets oversold.

Schema is not a ranking factor. Google has said this directly and repeatedly. Adding markup does not, by itself, move you up the results page.

What it does do:

Enables rich results

Star ratings, FAQ dropdowns, opening hours, event dates, breadcrumb trails — the extra detail some results get and others don’t. Those require structured data. Without it, you’re not eligible regardless of how well you rank.

Rich results don’t raise your position, but they make your listing physically larger and more informative, which tends to earn more clicks at the same position.

Removes ambiguity

Google has to decide whether your business serves Springfield, Illinois or Springfield, Missouri. Whether “Summit” is your company name or a word in a headline. Schema answers these questions instead of leaving them to inference.

For service-area businesses especially, this matters — you’re asking Google to understand a geography that isn’t a single street address.

Feeds the knowledge graph

Google maintains an entity database — a model of real things in the world and how they relate. Schema is how you contribute your business to it accurately, connecting your website, your Google Business Profile, and your social profiles as one entity rather than three unconnected mentions.

Increasingly, it feeds AI answers

As search shifts toward generated summaries, structured data is one of the clearest signals available about what a business is and does. Pages that state their facts explicitly are easier to cite correctly.

The schema types local businesses need

You don’t need most of what schema.org offers. For a typical local business, four types cover it.

LocalBusiness (and its subtypes)

The foundation. Critically, don’t use the generic LocalBusiness type if a more specific one exists — schema.org defines dozens:

Business	Type
Plumber	Plumber
Electrician	Electrician
Dentist	Dentist
Law firm	LegalService or Attorney
Restaurant	Restaurant
Roofer	RoofingContractor
HVAC	HVACBusiness
Auto repair	AutoRepair
Gym	ExerciseGym
Salon	HairSalon or BeautySalon

Specific beats generic every time. Plumber tells Google considerably more than LocalBusiness.

Core fields worth including:

{
  "@context": "https://schema.org",
  "@type": "Plumber",
  "name": "RapidFlow Plumbing",
  "image": "https://example.com/storefront.jpg",
  "telephone": "+15552001234",
  "email": "hello@example.com",
  "url": "https://example.com",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "1400 Guadalupe St",
    "addressLocality": "Austin",
    "addressRegion": "TX",
    "postalCode": "78701",
    "addressCountry": "US"
  },
  "openingHoursSpecification": [{
    "@type": "OpeningHoursSpecification",
    "dayOfWeek": ["Monday","Tuesday","Wednesday","Thursday","Friday"],
    "opens": "08:00",
    "closes": "18:00"
  }],
  "sameAs": [
    "https://www.facebook.com/example",
    "https://www.instagram.com/example"
  ]
}

Two fields deserve special attention:

sameAs lists your profiles elsewhere. This is what tells Google your website, Facebook page, and Google Business Profile are all the same organisation rather than coincidentally similar names.

Phone in E.164 format — +15552001234, not (555) 200-1234. Structured data wants the machine format even though your page displays the human one.

Service

For each distinct service you offer. Useful when you have dedicated pages per service, which you should.

{
  "@type": "Service",
  "name": "Emergency Drain Repair",
  "provider": { "@id": "https://example.com/#organization" },
  "areaServed": { "@type": "City", "name": "Austin, TX" },
  "serviceType": "Drain cleaning and emergency repair"
}

FAQPage

If a page has genuine questions and answers, marking them up can produce expandable FAQ results.

Two rules that trip people up: the questions and answers must be visibly on the page (marking up content that isn’t there is a guideline violation) and don’t put identical FAQ markup on every page. Duplicated across fifty pages, it’s noise.

BreadcrumbList

Tells Google your page hierarchy, and produces the Home › Services › Drain Repair trail in results instead of a bare URL. Cheap to add and it makes your listing more readable.

How to implement it

Use JSON-LD

There are three formats. Use JSON-LD — Google explicitly recommends it, and it sits in a single <script> block rather than being woven through your HTML, which means it can’t break when someone edits the page.

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

Connect entities with @id

This is the technique that separates competent markup from a pile of disconnected blocks. Give your organisation a stable identifier and reference it everywhere else:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Plumber",
      "@id": "https://example.com/#organization",
      "name": "RapidFlow Plumbing"
    },
    {
      "@type": "Service",
      "name": "Emergency Drain Repair",
      "provider": { "@id": "https://example.com/#organization" }
    }
  ]
}

Now the service is explicitly tied to the business rather than floating free. Across a whole site, this builds one coherent entity instead of dozens of unrelated fragments.

Put the right schema on the right page

• Homepage — LocalBusiness + Organization
• Service pages — Service, referencing the organisation
• Location pages — Service with areaServed set to that city
• Blog posts — BlogPosting with author and dates
• Any page with a real FAQ — FAQPage
• Every page below the top level — BreadcrumbList

The rules that get sites penalised

Structured data has guidelines, and violating them can cost you rich results entirely.

Only mark up what’s visible. If your FAQ schema contains questions not on the page, that’s a violation. Same for reviews, prices, and hours.

Never invent review data. Self-serving AggregateRating on your own site (reviews you wrote about yourself) is the most common abuse and Google has become strict about it. Reviews should come from a genuine third-party platform.

Keep it accurate. Hours in schema that contradict hours on your Google Business Profile create exactly the ambiguity you added markup to remove.

Don’t mark up content that isn’t yours.

The through-line: schema describes reality. The moment it describes something aspirational, it’s a liability.

Testing your markup

Three tools, all free:

Rich Results Test — paste a URL and Google reports which rich results the page is eligible for. This is the one that matters, because it reflects Google’s own interpretation.

Schema Markup Validator — checks syntax against the vocabulary. Catches typos and invalid property names.

Search Console → Enhancements — once your markup is live, Google reports errors across the whole site. This is where you find the problem you introduced on all thirty pages at once.

Test after every meaningful change. A trailing comma in JSON invalidates the entire block silently — no error message, the markup simply stops existing.

A realistic sequence

If you’re starting from nothing:

Week one. Add LocalBusiness (specific subtype) to your homepage with name, phone, address or service area, hours, URL, and sameAs. Test it. This alone puts you ahead of most local competitors.

Week two. Add BreadcrumbList sitewide and Service markup to each service page, referencing the organisation by @id.

Week three. Add FAQPage where you have real questions on the page. Add BlogPosting to articles.

Ongoing. Check Search Console monthly. Update hours in schema whenever they change in reality.

Where this fits in local SEO

Schema is one input among several, and it’s not the one with the biggest effect. If you’re choosing where to spend limited time:

1. Google Business Profile, fully completed — still the largest lever for local visibility
2. Genuine reviews, consistently gathered — see turning Google reviews into customers
3. Real pages for the areas you serve, not thin duplicates
4. Consistent name, address, phone everywhere you appear
5. Schema markup confirming all of the above

Schema makes the other four legible. It doesn’t replace any of them. The full picture is in our local SEO checklist and how to show up on Google Maps.

Frequently asked

Will schema make me rank higher? Not directly. Google has been explicit that structured data is not a ranking factor. What it does is make you eligible for richer results, which earn more clicks at the same position, and it removes ambiguity about what your business is and where it operates.

How long before I see anything? Google has to recrawl the page first, which can take days to weeks. Rich results appear only when Google decides to show them, and eligibility does not guarantee display.

Do I need a developer? For a simple LocalBusiness block, not necessarily. Most CMS platforms have a way to insert a script into the page head, and the JSON is copy-and-adjust. Anything more elaborate benefits from someone who can test it properly.

Can schema hurt me? Yes, if it describes things that aren’t on the page or aren’t true. Marking up reviews you wrote yourself, or FAQs that don’t appear to visitors, is a guidelines violation and can cost you rich results across the whole site.

What if my details change? Update the schema at the same time you update the page. Hours in markup that contradict your Google Business Profile create exactly the confusion you added markup to prevent.

Should every page have the same schema? No. Each page gets what describes that page. Duplicating your full LocalBusiness block on all fifty pages adds noise rather than signal.

Is JSON-LD better than microdata? For practical purposes yes. Google recommends it, it sits in one block rather than being woven through your HTML, and it survives content edits that would break inline markup.

How do I know it’s still working months later? Search Console reports structured data errors across the site under Enhancements. Check it monthly. A template change can silently invalidate markup on every page at once.

The short version

• Schema is a clarity tool, not a ranking hack
• Use the most specific type available — Plumber, not LocalBusiness
• JSON-LD, connected with @id so it describes one entity
• Only mark up what’s genuinely on the page and true
• Test with the Rich Results Test, then watch Search Console
• It unlocks eligibility for richer listings, which earn more clicks at the same position

It’s an afternoon of work that most of your competitors haven’t done.

---

Want this built in from the start? Every site we build ships with structured data configured for your industry and service area — schema, breadcrumbs, and local signals included, not sold as an add-on. See our services or find your city.