Schema markup for local businesses is a form of structured data – written in JSON-LD format and embedded in a page's <head> section – that tells search engines and AI systems exactly who you are, where you operate, and what you offer. Google uses this information to populate local Knowledge Panels, map results, and AI-generated answers. Without it, even a well-ranked local business page leaves search engines to infer the details, which introduces ambiguity that costs visibility. This tutorial walks through every schema type a local service business should implement, shows the exact JSON-LD to generate, and explains which fields are required versus recommended for maximum impact.

Most local business owners treat their Google Business Profile as the primary signal for local search. It matters, but it is not sufficient on its own. Schema markup on your website creates a second, authoritative source of structured information that search engines can cross-reference against your profile. When both signals agree, Google's confidence in your business data increases, directly improving your chances of appearing in map packs, Knowledge Panels, and AI Overviews.

The connection between structured data and AI visibility runs deeper than most practitioners recognize. AI systems like ChatGPT, Perplexity, and Google's AI Mode pull from sources that present information in clearly labeled, machine-readable formats. Schema markup is precisely that kind of signal. Schema's role in AI answer engine optimization is well documented: businesses that implement structured data correctly are consistently more likely to be cited in AI-generated local answers than those that rely on prose content alone.

For local and service businesses, five schema types do the heaviest lifting: LocalBusiness, GeoCoordinates, OpeningHoursSpecification, Review, and Service. Each maps to a different part of what Google and AI systems surface in response to location-based queries.

The Five Schema Types Every Local Business Needs

LocalBusiness

LocalBusiness is the foundational schema type. It extends Organization and tells search engines that your entity is a physical or service-area business with a real-world location. Every other schema type in this tutorial nests inside or alongside it.

Google uses LocalBusiness data to populate the Knowledge Panel that appears when someone searches your business name, and to verify the NAP (Name, Address, Phone) consistency that local ranking algorithms depend on.

Required fields:

Field Value Purpose
@type "LocalBusiness" or a subtype Defines the entity type
name Your exact business name Matches Google Business Profile
address PostalAddress object Enables map and Knowledge Panel
telephone Full number with country code NAP signal
url Homepage URL Entity anchor

Recommended fields:

Field Value Purpose
image URL of logo or primary photo Visual Knowledge Panel
priceRange e.g. "$$" User expectations
currenciesAccepted e.g. "USD" Disambiguation
paymentAccepted e.g. "Cash, Credit Card" Practical user info
areaServed City, region, or GeoShape Service-area businesses
sameAs Array of profile URLs Entity disambiguation

Practical exercise: Open your Google Business Profile and your website footer. Write down your business name, address, and phone number exactly as they appear in your GBP. These must match character-for-character in your schema markup. A mismatch – even a missing "Suite" or abbreviated street name – weakens the NAP signal.

The sameAs array is one of the most underused fields in local schema. It links your schema entity to your profiles on Yelp, Facebook, LinkedIn, and other authoritative directories, helping AI systems recognize your business as a well-defined entity across the web. Understanding how entity recognition shapes AI visibility clarifies why this field matters as much for generative answers as for traditional search.

GeoCoordinates

GeoCoordinates provides your precise latitude and longitude. Google can infer location from your address, but supplying explicit coordinates removes any ambiguity and strengthens your placement in map results. For businesses on unmarked roads, in business parks, or in areas where street-level geocoding is imprecise, this field is the difference between appearing on the map and being approximated onto it.

Required fields:

Field Value Purpose
@type "GeoCoordinates" Schema type declaration
latitude Decimal degrees, e.g. 37.7749 North-south position
longitude Decimal degrees, e.g. -122.4194 East-west position

Obtain your coordinates from Google Maps: right-click your business pin and copy the coordinates that appear at the top of the context menu. Do not round the values; use the full decimal precision.

GeoCoordinates nests inside the LocalBusiness object under the geo property rather than appearing as a separate schema block:

"geo": {
 "@type": "GeoCoordinates",
 "latitude": 37.7749,
 "longitude": -122.4194
}

OpeningHoursSpecification

Opening hours are among the most frequently queried pieces of local business information. Google surfaces them in map results, Knowledge Panels, and AI-generated answers to queries like "is [business] open now?" When your hours schema is absent or incorrect, Google falls back to unstructured sources or displays nothing at all.

OpeningHoursSpecification allows you to define hours per day, with support for different schedules on different days, holiday hours, and seasonal variations. Each specification is an object with dayOfWeek, opens, and closes fields.

Required fields:

Field Value Purpose
@type "OpeningHoursSpecification" Type declaration
dayOfWeek Schema.org day URI Which day applies
opens Time in HH:MM format Opening time
closes Time in HH:MM format Closing time

Days use Schema.org URIs: https://schema.org/Monday, https://schema.org/Tuesday, and so on through https://schema.org/Sunday. For businesses open 24 hours, set opens to "00:00" and closes to "23:59". For closed days, omit that day's specification entirely rather than setting hours to zero.

Practical exercise: Map your hours to a table before writing the JSON-LD. For businesses with identical weekday hours, you can list multiple days in an array within a single specification object to reduce repetition.

Review

Review schema and its companion AggregateRating markup allow Google to display star ratings in search results and Knowledge Panels. For local businesses competing on trust signals, rich results showing a 4.8-star average from 200 reviews can meaningfully increase click-through rates.

There is an important distinction between the two types:

Review Schema
Represents a single, individual review with reviewer name, rating value, and review body text.
AggregateRating Schema
Represents the compiled average of all reviews, expressed as a numerical score with a review count.

Google's guidelines specify that review markup should only be implemented on pages that contain actual review content visible to users. Do not add AggregateRating markup to a page that does not display ratings. Google actively enforces this and may apply a manual action for misleading structured data.

AggregateRating required fields:

Field Value Purpose
@type "AggregateRating" Type declaration
ratingValue Numerical average, e.g. "4.8" Average score
reviewCount Total number of reviews Statistical weight
bestRating Maximum possible rating, e.g. "5" Scale context

Practical exercise: If your website already shows a reviews section or embeds third-party reviews, you have the content basis for this markup. Audit your reviews page and count the total number of reviews and the average rating. Use those exact figures in your schema – do not inflate them.

Service

Service schema describes what your business actually does. While LocalBusiness identifies you, Service markup tells search engines and AI systems the specific offerings you provide, their descriptions, and in some cases their prices. This is particularly valuable for AI-generated answers to queries like "who offers [service] near me?" because AI systems can extract service-level detail from structured markup that prose descriptions do not provide as cleanly.

Core fields for Service schema:

Field Value Purpose
@type "Service" Type declaration
serviceType Plain-text service name Primary service identifier
name Display name of the service User-facing label
description 1–3 sentence description Content for AI extraction
provider Reference to the LocalBusiness entity Service-to-business link
areaServed City, region, or GeoShape Geographic scope
offers Offer object with pricing Rich result eligibility

Each service your business provides should have its own Service block. A plumbing company with four service types should implement four separate Service schema objects, not one generic block that lists all services in the description field.

The description field deserves careful attention. Write each service description as a self-contained statement that answers the implicit question "what does this service involve and who needs it?" This is the format AI systems extract and repeat when answering service-specific queries – the same principle behind content formats that AI systems are most likely to quote.

Building the Complete JSON-LD Block

The five schema types above do not live as five separate scripts on your page. They combine into a single, nested JSON-LD object, which is the implementation format Google recommends for structured data. JSON-LD (JavaScript Object Notation for Linked Data) is placed in a <script type="application/ld+json"> tag in the <head> section of your page.

Below is a complete, annotated example for a fictional plumbing company. Every field is labeled with an inline comment explaining its purpose.

<script type="application/ld+json">
{
 "@context": "https://schema.org",
 "@type": "Plumber",
 "name": "Meridian Plumbing Services",
 "url": "https://www.meridianplumbing.com",
 "logo": "https://www.meridianplumbing.com/images/logo.png",
 "image": "https://www.meridianplumbing.com/images/team-photo.jpg",
 "telephone": "+1-415-555-0192",
 "priceRange": "$$",
 "address": {
 "@type": "PostalAddress",
 "streetAddress": "841 Market Street, Suite 200",
 "addressLocality": "San Francisco",
 "addressRegion": "CA",
 "postalCode": "94102",
 "addressCountry": "US"
 },
 "geo": {
 "@type": "GeoCoordinates",
 "latitude": 37.7848,
 "longitude": -122.4066
 },
 "openingHoursSpecification": [
 {
 "@type": "OpeningHoursSpecification",
 "dayOfWeek": [
 "https://schema.org/Monday",
 "https://schema.org/Tuesday",
 "https://schema.org/Wednesday",
 "https://schema.org/Thursday",
 "https://schema.org/Friday"
 ],
 "opens": "07:00",
 "closes": "18:00"
 },
 {
 "@type": "OpeningHoursSpecification",
 "dayOfWeek": "https://schema.org/Saturday",
 "opens": "08:00",
 "closes": "14:00"
 }
 ],
 "aggregateRating": {
 "@type": "AggregateRating",
 "ratingValue": "4.9",
 "reviewCount": "214",
 "bestRating": "5"
 },
 "review": [
 {
 "@type": "Review",
 "author": {
 "@type": "Person",
 "name": "Sandra K."
 },
 "reviewRating": {
 "@type": "Rating",
 "ratingValue": "5",
 "bestRating": "5"
 },
 "reviewBody": "Meridian fixed a burst pipe within two hours of my call. Professional, fast, and transparent on pricing."
 }
 ],
 "hasOfferCatalog": {
 "@type": "OfferCatalog",
 "name": "Plumbing Services",
 "itemListElement": [
 {
 "@type": "Service",
 "serviceType": "Emergency Plumbing",
 "name": "24-Hour Emergency Plumbing",
 "description": "Same-day emergency repair for burst pipes, blocked drains, and water heater failures in the San Francisco Bay Area.",
 "provider": { "@id": "https://www.meridianplumbing.com" },
 "areaServed": "San Francisco, CA"
 },
 {
 "@type": "Service",
 "serviceType": "Drain Cleaning",
 "name": "Professional Drain Cleaning",
 "description": "Hydro-jetting and mechanical drain cleaning for residential and commercial properties with persistent blockages.",
 "provider": { "@id": "https://www.meridianplumbing.com" },
 "areaServed": "San Francisco, CA"
 }
 ]
 },
 "sameAs": [
 "https://www.yelp.com/biz/meridian-plumbing-services",
 "https://www.facebook.com/meridianplumbing",
 "https://www.linkedin.com/company/meridian-plumbing"
 ]
}
</script>

Practical exercise: Copy this block into a text editor. Replace every value – name, address, coordinates, hours, ratings, services, and sameAs URLs – with your own business data. Do not change the field names or structural syntax. Save the result and proceed to validation in the next section.

Notice the @type value is "Plumber" rather than the generic "LocalBusiness". Schema.org provides specific subtypes for dozens of business categories: Electrician, HVACBusiness, Dentist, LegalService, AutoRepair, and many others. Using the most specific subtype applicable to your business produces stronger classification signals than the generic parent type. A full list of LocalBusiness subtypes is available at schema.org/LocalBusiness.

Where to Add the Schema Markup on Your Site

JSON-LD schema belongs in the <head> section of the pages where the information is accurate and visible. For most local businesses, the correct implementation targets are:

Homepage

The homepage carries your primary LocalBusiness block – the complete nested object from the example above. This is the page Google most frequently associates with your business entity, so the full schema lives here.

Individual Service Pages

Each dedicated service page should carry its own Service schema block scoped to that service, with a provider property that references your main business entity by URL. This creates a structured relationship between your business and each service that AI systems can traverse when answering service-specific queries.

Contact Page

If your contact page displays your address, hours, and phone number (as most do), duplicate the core LocalBusiness fields there. Consistency across pages reinforces the NAP signal.

Implementation Without a Developer

For businesses without developer resources, several CMS plugins and no-code tools handle JSON-LD injection. The schema implementation options for non-developers cover Google Tag Manager, WordPress plugins, and direct theme file editing as viable paths. For WordPress specifically, the WordPress schema implementation workflow walks through plugin-based and manual approaches with step-by-step instructions.

For teams that want to generate schema from an existing URL rather than writing it from scratch, the AuthorityStack.ai free schema generator scans a page's content and outputs ready-to-copy JSON-LD – a practical starting point before manual customization.

Validating Your Schema Implementation

Writing valid JSON-LD syntax is not sufficient. The markup must also be semantically correct – using the right fields for the right schema types, with values that match what appears on the page.

Step 1: Syntax Validation

Paste your JSON-LD into jsonlint.com to confirm the JSON syntax is valid. A single misplaced comma or unclosed bracket will cause the entire block to fail silently.

Step 2: Schema Validation

Run your page URL or raw code through Google's Rich Results Test at search.google.com/test/rich-results. This tool confirms which rich result types your markup qualifies for and flags any missing required fields or policy violations.

Step 3: Coverage Check

Use Google Search Console's "Enhancements" section to monitor indexing status of your structured data over time. Errors flagged here indicate fields that were valid when you submitted but conflict with page content – the most common cause being ratings markup on a page where no reviews are displayed.

Common validation errors and their causes:

Error Cause Fix
Missing field: name Field omitted or misspelled Add "name" to LocalBusiness block
Unparseable structured data JSON syntax error Validate with JSONLint
Rating without review content AggregateRating on page with no visible reviews Add visible review content or remove markup
Coordinates out of range Latitude/longitude values are swapped Latitude is the first value; longitude is the second
Inconsistent telephone format Different formats across pages Standardize to E.164 format: +15550001234

How This Schema Maps to Google's Local Knowledge Panel

Once Google processes your structured data, each schema field maps to a specific element in the local search experience:

Schema Field Where Google Surfaces It
name + @type Knowledge Panel header and map pin label
address Knowledge Panel address row and Maps placement
geo Precise pin location on Google Maps
telephone "Call" button in Knowledge Panel
openingHoursSpecification Hours row with "Open/Closed" status
aggregateRating Star rating in search results and Knowledge Panel
review Review snippets in Knowledge Panel
Service + description "Services" section in Knowledge Panel (where eligible)
sameAs Entity disambiguation across knowledge graph

The Knowledge Panel is not guaranteed by schema markup alone – Google exercises editorial control over when and how panels appear. But structured data is the clearest signal you can send to make the panel accurate when it does appear. For businesses targeting AI-generated local answers alongside traditional local SEO, the overlap is significant: the same structured data that populates a Knowledge Panel also feeds the entity graph that AI systems query when answering location-based questions.

Across all five schema types, the distinction between required and recommended fields determines whether your markup qualifies for rich results (required) versus how completely Google and AI systems can represent your business (recommended).

Schema Type Required Fields Recommended for Maximum Visibility
LocalBusiness name, address, @type telephone, url, image, sameAs, priceRange, areaServed
GeoCoordinates latitude, longitude Full decimal precision (6+ decimal places)
OpeningHoursSpecification dayOfWeek, opens, closes Separate specs for holidays and special hours
AggregateRating ratingValue, reviewCount bestRating, worstRating
Review author, reviewRating, reviewBody datePublished, publisher
Service name, serviceType description, areaServed, provider, offers

The practical principle: implement every required field first, then work through the recommended fields in order of likely impact. For most local businesses, sameAs, areaServed, and Service descriptions deliver the most incremental value after the required baseline is in place.

Schema Markup, AI Visibility, and What Comes Next

The gap between traditional local SEO and AI-driven local discovery is closing faster than most local businesses recognize. When someone asks ChatGPT "what's the best HVAC company in Austin?" or Perplexity "find a family dentist near downtown Chicago open on Saturdays," these systems synthesize answers from sources they can parse clearly. Businesses with complete, accurate LocalBusiness schema – including Service descriptions, hours, and coordinates – are structurally better positioned to appear in those answers than businesses whose information exists only in prose or unstructured directory listings.

Schema markup also intersects with topical authority building: the more consistently your entity is described across your website, your schema, and external profiles, the more confidently AI systems can classify and recommend your business for relevant queries. The signals that tell AI your brand is authoritative extend well beyond content quality to include this kind of structured entity consistency.

Looking ahead, three developments are worth monitoring:

AI Mode and local intent queries. Google's AI Mode increasingly handles queries with local intent directly, synthesizing business information from Knowledge Panels, reviews, and structured data without sending users to additional pages. Businesses with complete schema are better represented in these synthesized answers.

Service-level AI answers. As AI systems become more capable of answering narrow, service-specific queries ("who does same-day appliance repair near me?"), the Service schema type grows proportionally more valuable. The specificity of your service descriptions determines whether your business can be matched to these queries.

Schema as an entity graph signal. Search and AI systems are increasingly reasoning about entities and their relationships rather than just keywords and backlinks. Schema markup is a direct input to this entity graph. Businesses that invest in complete, accurate structured data now are building an asset whose value compounds as AI-driven search continues to expand.

The schema types that most directly affect both SEO and GEO outcomes are already the ones covered in this tutorial. Implementing them correctly is not a future-proofing exercise – it is a present-day requirement for local businesses that want to be found across both traditional and AI-powered search.

Frequently Asked Questions

What Is the Difference Between LocalBusiness Schema and Organization Schema?

Organization is the parent type that represents any organization, commercial or non-commercial. LocalBusiness is a subtype of Organization specifically for entities with a physical location or defined service area. Local businesses should always use LocalBusiness or a more specific subtype – such as Dentist, Plumber, or Restaurant – rather than the generic Organization type, because the more specific type produces stronger classification signals in both search and AI systems.

Do I Need a Separate Schema Block for Each Page on My Website?

Not necessarily. Your primary LocalBusiness block belongs on your homepage. Individual service pages should carry Service schema relevant to that page's content, with a provider reference back to the main business entity. Pages that do not introduce new entity information – blog posts, privacy policies, team bio pages – generally do not require additional schema blocks.

How Do I Get Star Ratings to Appear in Google Search Results?

Star ratings appear in search results through AggregateRating schema, but only on pages that visibly display review content to users. Implement AggregateRating markup on any page where your ratings and reviews are visible: a dedicated reviews page, a homepage reviews section, or individual product or service pages with review embeds. Google will not display the stars if the markup exists but no visible review content supports it.

Can Schema Markup Hurt My Rankings If Implemented Incorrectly?

Schema markup errors that are simply incomplete or use wrong field names will cause your markup to be ignored – your page will not qualify for rich results, but no ranking penalty applies. Google does issue manual actions for deliberately misleading structured data, such as claiming ratings higher than your actual reviews, adding fake review counts, or marking up content that is not present on the page. Implement only what is accurate and visible.

How Often Should I Update My Schema Markup?

Update your schema whenever the underlying business information changes: new address, revised hours, updated phone number, added services, or significant changes to your average rating. Stale schema that contradicts your Google Business Profile or actual page content weakens your NAP signal. Treat your JSON-LD block as living documentation, not a one-time implementation.

Does Schema Markup Directly Improve My Google Maps Ranking?

Schema markup is not a direct ranking signal in Google Maps the way review volume and proximity are. Its primary effect is accuracy and disambiguation: correct coordinates ensure your pin appears in the right location, and complete NAP data ensures Google treats your website and your Google Business Profile as the same entity. That entity consolidation indirectly supports local ranking by eliminating ambiguity that can fragment your authority across multiple incomplete records.

Which Schema Type Matters Most for AI-generated Local Answers?

Service schema with detailed description fields is the type most directly useful for AI-generated answers to local service queries, because it gives AI systems structured, extractable text that matches the specificity of natural language questions. LocalBusiness with a complete sameAs array matters most for entity recognition across AI knowledge graphs. Both are necessary – LocalBusiness establishes who you are, Service establishes what you do.

Is JSON-LD the Only Format I Can Use for Local Business Schema?

Google supports three structured data formats – JSON-LD, Microdata, and RDFa but officially recommends JSON-LD because it sits in the <head> section and does not interleave with visible HTML. JSON-LD is also the easiest to maintain: updating a single script block is simpler than editing attributes distributed throughout a page's HTML. Both free and paid schema generation tools output JSON-LD by default for this reason.

Next Steps

  • Confirm your business name, address, and phone number match exactly between your Google Business Profile and your website
  • Identify the most specific LocalBusiness subtype for your business category at schema.org/LocalBusiness
  • Write a Service description for each offering you provide – aim for two to three sentences per service, self-contained and specific
  • Assemble the complete JSON-LD block following the template above and validate it through Google's Rich Results Test
  • Deploy the markup to your homepage, service pages, and contact page
  • Check Google Search Console's Enhancements tab after two to three weeks to confirm Google has processed the markup without errors

For teams that want to generate and audit schema without writing JSON-LD manually, the AuthorityStack.ai free schema generator scans any URL and outputs ready-to-implement structured data in seconds. To go further and track how your structured data contributes to AI citation visibility across ChatGPT, Claude, Gemini, and Perplexity, improve your AI visibility with a free check of where your content currently stands.