Local SEO · August 10, 2026 · 32 min read
Schema markup for local businesses: what it is, why it matters, and how to add it
Schema markup is structured data that tells Google exactly what your business is, where it is, and what it does. It's not magic, it's just facts in a format Google can read instantly.
A Brattleboro HVAC contractor has a perfectly good website. His contact page lists his business name, address, and phone number. His homepage explains what he does. His about page mentions he has been serving Windham County for twelve years. A human reading the site understands all of this in thirty seconds. Google's crawler reads the same site and sees a bunch of text with no clear structure. It can guess that "Smith HVAC" is the business name and "123 Main Street, Brattleboro, VT 05301" is probably the address, but it has to infer that from context. It might get it wrong. It might miss half of it. Or it might see the information but not be confident enough to use it in search results, because the data is not explicitly labeled.
Schema markup fixes that. It is a piece of structured data (usually in JSON-LD format, which is just a snippet of code) that you add to your website to tell Google exactly what things are. Not "here is some text that probably includes a phone number," but "this is the business name, this is the address, this is the phone number, this is the service area, these are the hours." Google reads schema instantly, understands it perfectly, and uses it to display your business information more accurately in search results and to boost your local rankings because it can verify your details with confidence.
You do not need to be a developer to add schema. You do not need to understand how JSON works. You need to know what information to include, where to put it on your site, and how to test it to make sure it is working. Do that and you give Google a direct, unambiguous feed of your business facts, which makes you more likely to show up in local searches, more likely to appear in rich results, and more likely to rank higher than competitors who are making Google guess.
What schema markup actually is (and why JSON-LD is the format you want)
Schema markup is structured data. Structured data is information formatted in a way that machines can read and understand without ambiguity. Instead of writing "We're open Monday through Friday from 9 to 5," you write a piece of code that says "openingHours": "Mo-Fr 09:00-17:00" in a standardized format. Google's crawler sees that, knows exactly what it means, and can use it immediately.
Schema.org is the vocabulary. It is a collaboration between Google, Microsoft, Yahoo, and Yandex that defines what types of things can be marked up (businesses, events, recipes, products, reviews, etc.) and what properties each type has (a LocalBusiness has a name, address, phone, hours, etc.). You go to schema.org, find the type that matches what you are marking up (LocalBusiness for most small businesses in Windham County), and see the full list of properties you can include.
JSON-LD is the format. JSON stands for JavaScript Object Notation. LD stands for Linked Data. JSON-LD is a way of writing schema markup as a script tag in your HTML that Google can read easily. It looks like this:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "LocalBusiness",
"name": "Smith HVAC",
"address": {
"@type": "PostalAddress",
"streetAddress": "123 Main Street",
"addressLocality": "Brattleboro",
"addressRegion": "VT",
"postalCode": "05301"
},
"telephone": "+1-802-555-1200",
"openingHours": "Mo-Fr 09:00-17:00"
}
</script>That is schema markup in JSON-LD format. It is a script tag that sits in the HTML of your homepage (usually in the <head> section or right before the closing </body> tag). Google crawls your page, sees that script, reads the structured data, and knows with 100% certainty that your business name is "Smith HVAC," your address is "123 Main Street, Brattleboro, VT 05301," your phone is (802) 555-1200, and you are open Monday through Friday from 9 a.m. to 5 p.m.
There are other formats for schema (Microdata and RDFa), but JSON-LD is what Google recommends because it is cleaner, easier to add and edit, and does not require you to modify the visible content of your page. You just drop a script tag into your HTML and you are done.
A Putney contractor added LocalBusiness schema to his homepage in JSON-LD format. The schema included his business name, address, phone, hours, service area (Windham County towns), and a link to his logo. He tested it in Google's Rich Results Test (more on that below), confirmed it was valid, and published it. Within two weeks Google started displaying his hours directly in search results when people searched for his business name. Within a month his rankings improved slightly in three towns where he had been borderline (fourth or fifth in the map pack), because Google could now verify his NAP and service area with certainty instead of inferring it from page text.
Why schema matters for local SEO (and what it does not do)
Schema markup does not guarantee you will rank first. It is not a magic ranking boost. It is a verification and clarity signal. When you add schema, you are making it easier for Google to understand your business, which removes ambiguity and increases Google's confidence in your information. Higher confidence means your business is more likely to show up for relevant searches, more likely to rank well in the map pack, and more likely to appear in rich results (the enhanced search listings that show hours, ratings, photos, etc.).
Here is what schema does for local businesses:
Verifies your NAP. If your schema lists your name, address, and phone, and those match your Google Business Profile and your on-page content, Google sees consistent signals and treats your business as verified and trustworthy. If you do not have schema, Google has to guess which parts of your page are the business name, address, and phone, and it might get it wrong or miss it entirely.
Reinforces your service area. LocalBusiness schema has a property called areaServed where you can list the towns, cities, or regions you serve. If you add "areaServed": ["Brattleboro", "Putney", "Bellows Falls", "Wilmington"], Google knows explicitly that you serve those towns, which helps you rank in local searches for those areas.
Displays your hours in search results. If you include openingHours in your schema and it matches your Google Business Profile hours, Google can show your hours directly in search results, which is helpful for searchers and increases click-through rate.
Enables rich results. Rich results are the enhanced listings in search that show extra information like star ratings, price range, photos, etc. Schema markup is a prerequisite for most rich results. If you do not have schema, you will not get rich results, even if you have great reviews and photos.
Helps Google understand your business type. The @type property in your schema tells Google what kind of business you are. If you are a plumber, you can use "@type": "Plumber" (which is a subtype of LocalBusiness). If you are a restaurant, "@type": "Restaurant". If you are a law firm, "@type": "Attorney". The more specific the type, the better Google can match you to relevant searches.
What schema does not do:
It does not replace your Google Business Profile. Schema on your website and your Google Business Profile are two separate signals. Both matter. Schema reinforces what is on your profile, but it does not replace it. You need both.
It does not guarantee rich results. Even if your schema is perfect, Google decides whether to show rich results based on query intent, competition, and other factors. Schema makes you eligible for rich results, but it does not guarantee them.
It does not fix bad information. If your schema has the wrong address or phone number, it will hurt you, not help you. Schema amplifies whatever information you include, so if that information is wrong or inconsistent with your Google profile, you are making the problem worse.
A Bellows Falls retail shop added schema to their homepage that included their business name, address, phone, and hours. The schema address was "123 Depot Street, Bellows Falls, VT 05101." Their Google Business Profile address was "123 Depot St, Bellows Falls, VT 05101" (abbreviated "St" instead of spelled-out "Street"). The inconsistency was minor, but it was still an inconsistency. We updated the schema to match the Google profile exactly (abbreviated "St"), and the signal aligned. Two weeks later their local rankings improved slightly, because Google could now verify the address across both sources without any ambiguity.
The LocalBusiness schema properties you should include
LocalBusiness is the schema type for most small businesses. If you run a service business, retail shop, restaurant, office, or storefront in Windham County, LocalBusiness is your type. There are more specific subtypes (Plumber, Electrician, Restaurant, LegalService, etc.), and you should use the most specific type that fits, but they all inherit from LocalBusiness, so the core properties are the same.
Here are the properties you should include in your LocalBusiness schema, in order of importance:
Required properties (include these always)
@context and @type: These tell Google what schema vocabulary you are using and what type of thing you are marking up. Always "@context": "https://schema.org" and "@type": "LocalBusiness" (or a more specific subtype).
name: Your business name, exactly as it appears on your Google Business Profile. "Smith HVAC," not "Smith HVAC LLC" unless that is what your profile says.
address: A nested PostalAddress object with streetAddress, addressLocality (city/town), addressRegion (state, two-letter abbreviation), and postalCode. Format it exactly the same way as your Google Business Profile address for consistency.
Example:
"address": {
"@type": "PostalAddress",
"streetAddress": "123 Main Street",
"addressLocality": "Brattleboro",
"addressRegion": "VT",
"postalCode": "05301"
}telephone: Your business phone number, formatted the same way as your Google Business Profile. Use the international format with country code for maximum clarity: "+1-802-555-1200".
Recommended properties (include these if applicable)
url: The URL of your homepage. "url": "https://yourwebsite.com"
image: A URL to your business logo or a representative photo. This can appear in rich results. "image": "https://yourwebsite.com/logo.png"
openingHours: Your business hours in schema format. The format is "Mo-Fr 09:00-17:00" for Monday through Friday, 9 a.m. to 5 p.m. If you have different hours on different days, you can list them separately or use multiple strings:
"openingHours": [
"Mo-Fr 09:00-17:00",
"Sa 10:00-14:00"
]If you are closed on a day, omit it (do not include "Su 00:00-00:00" or anything like that). Google will assume you are closed.
priceRange: A rough indicator of your pricing, usually as dollar signs ($, $$, $$$, or $$$$). This is subjective but helpful for searchers. A budget plumber might use "$", a mid-range contractor might use "$$", a high-end designer might use "$$$".
areaServed: The towns, cities, or regions you serve. You can list them as an array of strings:
"areaServed": [
"Brattleboro, VT",
"Putney, VT",
"Bellows Falls, VT",
"Wilmington, VT"
]Or you can use structured Place objects if you want to be more specific, but a simple array of town names is usually enough.
geo: Geographic coordinates (latitude and longitude) for your business location. This helps Google place you on the map with precision.
"geo": {
"@type": "GeoCoordinates",
"latitude": "42.8509",
"longitude": "-72.5579"
}You can find your coordinates by searching for your address on Google Maps, right-clicking the location pin, and selecting "What's here?" The coordinates will appear at the bottom of the screen.
sameAs: Links to your social media profiles and other online presences (Yelp, Facebook, LinkedIn, etc.). This helps Google verify your business identity across the web.
"sameAs": [
"https://www.facebook.com/yourpage",
"https://www.yelp.com/biz/yourbusiness",
"https://www.linkedin.com/company/yourcompany"
]Optional properties (include if you have them)
aggregateRating: If you have reviews on your website (not just on Google), you can mark them up with aggregateRating schema. This includes your average star rating and the number of reviews. If done correctly, this can show star ratings in search results (though Google is picky about displaying them, and they require that the reviews be genuine and visible on your site).
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.8",
"reviewCount": "42"
}logo: A URL to your official business logo. Similar to image, but specifically for branding.
founder or employee: If you want to mark up the owner or key people, you can include Person schema. This is optional and mostly useful for personal brands or professional services.
paymentAccepted: What payment methods you accept ("Cash, Credit Card, Check," etc.). Minor signal, but easy to include if applicable.
A Wilmington cleaning service added LocalBusiness schema to their homepage with all the core properties: name, address, phone, hours, service area (Wilmington, West Dover, Dover, Marlboro), price range ($$), logo, and geo coordinates. They tested it in Rich Results Test, confirmed it was valid, and published it. Within three weeks Google started showing their hours in search results when people searched "cleaning service Wilmington VT." Within two months they moved from third to second in the map pack for that search, and their click-through rate from search increased noticeably (because the hours were visible right in the search results, so searchers knew they were open before they even clicked).
Where to add schema markup on your site (homepage is the priority)
Schema markup for your business should live on your homepage. That is the most important page for local SEO, it is the page Google crawls most frequently, and it is the page that represents your business as a whole. Add your LocalBusiness schema to the <head> section of your homepage HTML, or right before the closing </body> tag (both work; <head> is slightly cleaner).
If you have location-specific pages (e.g., a "Brattleboro Services" page and a "Bellows Falls Services" page), you can add location-specific schema to each of those pages with the relevant address and service area. But the homepage schema is the foundation. Start there.
You only need one instance of LocalBusiness schema per page. Do not duplicate it or include multiple versions with slightly different information. That confuses Google. One clean, complete schema block is all you need.
If you are using a website builder or CMS (WordPress, Squarespace, Wix, etc.), there are plugins or built-in tools that let you add schema without touching the HTML directly. For WordPress, plugins like Yoast SEO, Rank Math, or Schema Pro have schema generators. For Squarespace or Wix, you can add a "code block" or "embed code" element and paste your JSON-LD script into it. For a custom-built site (like the ones we build at Brattleboro Local), your developer can add it directly to the template.
A Townshend contractor had a custom PHP site. We added LocalBusiness schema to the homepage template as a script tag in the <head>. The schema included his business name, address, phone, hours, service area (Townshend, Grafton, Londonderry, Jamaica, Windham), logo, and geo coordinates. The code was 20 lines, took five minutes to add, and has been live ever since. Every time Google crawls his homepage, it reads that schema and confirms his business details. His rankings improved slightly across all five towns he serves, and his Google Business Profile started showing up more consistently in "near me" searches from those areas.
How to create your schema markup (the manual way and the tool-assisted way)
You can write schema markup by hand, or you can use a generator tool that builds it for you. Both work. The manual way gives you full control and teaches you how it works. The tool-assisted way is faster and less error-prone if you are not comfortable editing code.
Manual method: write the JSON-LD yourself
Go to schema.org/LocalBusiness and review the list of properties. Open a text editor (Notepad, TextEdit, VS Code, whatever you use). Start with the basic structure:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "LocalBusiness",
"name": "Your Business Name",
"address": {
"@type": "PostalAddress",
"streetAddress": "123 Your Street",
"addressLocality": "Your Town",
"addressRegion": "VT",
"postalCode": "05301"
},
"telephone": "+1-802-555-1234"
}
</script>Replace the placeholder text with your actual business information. Add additional properties (url, image, openingHours, areaServed, etc.) as needed. Make sure every opening brace { has a matching closing brace }, every opening bracket [ has a matching closing bracket ], and every property except the last one in an object has a comma after it.
Save the code, copy it, and paste it into your website's HTML (in the <head> or before </body> on your homepage). Publish the page. Then test it (see next section).
Tool-assisted method: use a schema generator
Several free tools will generate LocalBusiness schema for you:
Google's Structured Data Markup Helper (search for it): You paste your homepage URL, the tool crawls the page, and you tag elements (click on your business name, your address, your phone number, etc.) to tell the tool what each piece of information is. When you are done, it generates the JSON-LD code for you. You copy it and paste it into your site.
Merkle's Schema Markup Generator (technicalseo.com/tools/schema-markup-generator/): A simple form where you fill in your business name, address, phone, etc., and it outputs the JSON-LD code. Fast and straightforward.
Hall Analysis Local Business Schema Generator: Another form-based tool that covers most LocalBusiness properties. Free and easy to use.
Rank Math or Yoast (WordPress plugins): If you use WordPress, both of these SEO plugins have built-in schema generators. You fill in your business info in the plugin settings, and it automatically adds the JSON-LD to your site. No manual code required.
The tool-generated schema is usually clean and valid, but always test it (next section) to make sure there are no errors or missing properties.
A Londonderry electrician used Merkle's schema generator to create his LocalBusiness schema. He filled in his business name, address, phone, hours, service area, and logo URL. The tool generated the JSON-LD code. He copied it, logged into his website (a basic HTML site his nephew had built years ago), opened the homepage file, pasted the schema code into the <head> section, and saved it. He tested it in Rich Results Test, saw that it was valid with no errors, and called it done. Total time: ten minutes. His local rankings improved slightly over the next month because Google could now verify his NAP with certainty.
How to test your schema markup (and fix errors before Google sees them)
After you add schema to your site, you need to test it to make sure it is valid and Google can read it. Google provides a free tool for this: Rich Results Test (search.google.com/test/rich-results).
How to use it:
Step one: Go to search.google.com/test/rich-results.
Step two: Enter your homepage URL (the page where you added the schema) and click "Test URL." The tool will crawl the page, extract any schema markup it finds, and validate it.
Step three: Review the results. If the schema is valid, you will see a green checkmark and a message like "Page is eligible for rich results." You will also see a preview of what properties Google detected (business name, address, phone, hours, etc.).
Step four: If there are errors, the tool will list them. Common errors include missing required properties (like @context or @type), formatting mistakes (missing commas, mismatched brackets), or invalid property values (like a phone number in the wrong format). Fix the errors in your schema code, re-publish the page, and test again.
Step five: If there are warnings (not errors, but suggestions for improvement), review them and decide whether to fix them. Warnings usually mean you are missing optional properties that would make the schema more complete (like openingHours or geo). Fixing warnings is not required, but it is a good idea if the properties are applicable.
You can also test schema using the old Structured Data Testing Tool (validator.schema.org), which is maintained by the schema.org project and is still functional. It is more technical and less user-friendly than Rich Results Test, but it validates schema against the full schema.org spec, which can be helpful for catching edge-case errors.
A Brattleboro bookkeeper added LocalBusiness schema to her homepage, tested it in Rich Results Test, and got an error: "Missing field 'address.addressRegion'." She had included the street address, city, and ZIP code, but forgotten to include the state abbreviation. She added "addressRegion": "VT" to the schema, re-published the page, tested again, and got a green checkmark. The schema was now valid and Google could read it.
Common schema mistakes and how to avoid them
Most schema errors are formatting mistakes or missing required properties. Here are the ones we see most often:
Mistake one: Inconsistent NAP
Your schema lists one address or phone number, and your Google Business Profile or website footer lists a different one. Google sees the inconsistency and downgrades your authority. Fix: make sure your schema NAP matches your Google profile and your on-page content exactly (same spelling, same abbreviation, same format).
Mistake two: Invalid JSON syntax
A missing comma, an extra comma, a mismatched bracket, or a quote mark that is not closed. JSON is picky about syntax. One small mistake breaks the whole thing. Fix: use a JSON validator (jsonlint.com) to check your code before you add it to your site. Copy your schema code, paste it into JSONLint, click "Validate JSON," and it will tell you if there are syntax errors.
Mistake three: Wrong @type
Using "@type": "Organization" instead of "@type": "LocalBusiness", or using a generic type instead of a specific subtype. Organization is too broad for local businesses. LocalBusiness (or a subtype like Plumber, Restaurant, Attorney) is what you want. Fix: check schema.org/LocalBusiness for the list of subtypes and use the most specific one that fits.
Mistake four: Hours in the wrong format
Google expects opening hours in a specific format: "Mo-Fr 09:00-17:00" (day range, space, time range in 24-hour format). If you write "Monday-Friday 9am-5pm" or "9-5 weekdays", Google will not understand it. Fix: use the schema.org format exactly. Two-letter day abbreviations (Mo, Tu, We, Th, Fr, Sa, Su), 24-hour time (09:00, not 9am), hyphen between start and end times.
Mistake five: Multiple conflicting schema blocks
Adding schema in two places on the same page (e.g., once in the <head> and once in the footer) with slightly different information. Google reads both, sees the conflict, and does not know which one to trust. Fix: one schema block per page, one source of truth.
Mistake six: Not testing before publishing
Adding schema to your site, assuming it is correct, and never testing it. Weeks or months later you discover it had a syntax error and Google has been ignoring it the whole time. Fix: always test in Rich Results Test before and after you publish. Takes two minutes, saves weeks of wasted opportunity.
A Putney contractor added LocalBusiness schema to his homepage and did not test it. Three months later he ran an SEO audit and discovered the schema had a syntax error (missing closing brace) and Google had been unable to read it. He fixed the error, tested it, confirmed it was valid, and re-published. Within two weeks his local rankings improved slightly, because Google could now read the schema and verify his business details. He had lost three months of potential ranking benefit because of one missing character.
Service-area businesses: how to handle schema when you have no public storefront
If you are a plumber, contractor, cleaner, or other service-area business with no public storefront, you still add LocalBusiness schema, but you handle the address property differently.
Option one: include your business address (even if it is your home office) in the schema, and match it to your Google Business Profile address (even if you hide the address from public view on Google). This gives Google a consistent NAP signal across your website and your profile.
Option two: omit the address from the schema entirely and only include service area, phone, and other properties. This is less common and may reduce the strength of your local SEO signals, but it works if you genuinely do not have a fixed address and operate purely as a service-area business.
Most service-area businesses should use option one: include the address in schema, make sure it matches the Google Business Profile address (even if that address is hidden from public view on Google), and also include areaServed to specify the towns you serve.
A Bellows Falls mobile mechanic has no shop. He works out of his home and drives to customers. His Google Business Profile lists his home address but hides it from public view (service-area business setting). His website schema includes the same home address in the address property, and also includes "areaServed": ["Bellows Falls", "Rockingham", "Springfield", "Chester", "Grafton"]. Google can verify his base location via the schema and knows he serves those five towns via the areaServed property. His rankings improved in all five towns after he added the schema, because Google could now explicitly confirm his service area instead of inferring it from page text.
How long it takes for schema to impact rankings
Schema is not an instant ranking boost. After you add it, Google needs to re-crawl your page, read the schema, validate it, and incorporate the information into its index. That process can take days to weeks depending on how frequently Google crawls your site.
Typical timeline:
Day one: You add schema to your homepage and test it in Rich Results Test. It is valid.
Days two through seven: Google re-crawls your homepage (this happens automatically; you can also request a re-crawl via Google Search Console by submitting the URL for indexing). Google reads the schema and validates it.
Weeks two through four: Google starts using the schema data to verify your business information and may begin displaying rich results (hours, ratings, etc.) in search results. Your local rankings may improve slightly if the schema resolved ambiguity or inconsistencies.
Months two through three: The schema becomes part of your site's long-term SEO foundation. It contributes to ranking stability, eligibility for rich results, and authority signals, all of which compound over time.
The impact is gradual and often subtle. You will not jump from fifth to first just because you added schema. But if you were borderline (fourth or fifth in the map pack), schema can be the tipping point that moves you into the top three. And if your competitors do not have schema, you have a small but real advantage.
A Newfane landscaper added LocalBusiness schema to his homepage in March. By April, Google was displaying his hours in search results for his business name. By May, he noticed his rankings had improved slightly in three towns where he had been fourth or fifth (he moved to third in two of them and stayed fourth in the third). By June, his organic traffic from local searches was up 15% compared to the prior year, and he attributed about half of that to the schema (the other half was consistent review growth and NAP consistency fixes he had made around the same time). The schema alone did not transform his business, but it was one piece of a broader local SEO strategy that compounded over time.
Other schema types that might apply to your business
LocalBusiness is the core type, but depending on what you do, you might also use or combine other schema types:
Service schema: If you offer specific services (HVAC repair, plumbing, electrical work, etc.), you can mark up each service with Service schema. This can appear on service-specific pages and includes properties like serviceType, provider, areaServed, and offers. Service schema is more granular than LocalBusiness and can help you rank for specific service queries ("furnace repair Brattleboro," "kitchen remodel Putney," etc.).
Review schema: If you display customer reviews on your website (not just on Google), you can mark them up with Review schema. This includes the reviewer's name, the rating, the review text, and the date. If you have multiple reviews, you can also use AggregateRating schema (which rolls up all your reviews into an average rating and count). This can enable star ratings to appear in search results, though Google is selective about displaying them.
Event schema: If you host events (workshops, open houses, classes, etc.), mark them up with Event schema. This can make your events eligible to appear in Google's Events search and rich results.
Product schema: If you sell physical products on your website, mark them up with Product schema. This includes properties like name, image, description, price, availability, and reviews. Product schema can enable product rich results (showing price and availability right in search results).
FAQPage schema: If you have a frequently asked questions page, you can mark up each Q&A pair with FAQPage schema. This can make your FAQs eligible to appear as expandable rich results in search.
For most local businesses in Windham County, LocalBusiness schema is the priority. If you offer multiple distinct services, Service schema is the next step. If you have reviews on your site, Review/AggregateRating schema is worth adding. The others are more specialized and only apply if you have the corresponding content on your site.
A Brattleboro law firm added LocalBusiness schema to their homepage and Service schema to their practice area pages (estate planning, real estate law, family law, etc.). Each service page had its own Service schema block with the service name, description, provider (the law firm), and areaServed (Windham County). Within two months, the firm started ranking on the first page for queries like "estate planning lawyer Brattleboro" and "real estate attorney Windham County," searches they had been on page two or three for previously. The combination of LocalBusiness schema (verifying the firm's NAP and location) and Service schema (clarifying exactly what services they offered) gave Google explicit signals that matched those search queries.
Schema markup for businesses with multiple locations
If you have two or more physical locations (e.g., one office in Brattleboro and one in Bellows Falls), you should have separate LocalBusiness schema for each location. The easiest way to do this is to create separate pages for each location (a "Brattleboro Office" page and a "Bellows Falls Office" page), and add location-specific schema to each page.
Each schema block should include the name of the location (e.g., "Smith Law - Brattleboro Office"), the specific address for that location, the phone number for that location (if different), and the hours for that location. If the locations share some information (same website URL, same logo, same social profiles), you can include those in both schema blocks.
Do not put multiple LocalBusiness schema blocks on the same page unless they represent genuinely different physical locations. Google will get confused and may ignore both.
You should also have separate Google Business Profiles for each location, and the schema for each location should match the corresponding profile (same address, same phone, same hours).
A Windham County insurance agency has three offices: Brattleboro, Bellows Falls, and Wilmington. Their website has a locations page with all three addresses, and separate detail pages for each office (brattleborolocal.com/locations/brattleboro, /locations/bellows-falls, /locations/wilmington). Each detail page has its own LocalBusiness schema with the office-specific name, address, phone, and hours. Each office also has its own Google Business Profile, and the schema matches the profile for that office. This structure gives Google clear, unambiguous signals for all three locations, and the agency ranks in the map pack for all three towns.
What to do if you are not comfortable editing code
If you do not have access to your website's HTML, or you are not comfortable editing code, you have a few options:
Hire your web developer or designer to add it. If you paid someone to build your site, they can add schema in ten minutes. Send them this guide or a link to schema.org/LocalBusiness, and ask them to add LocalBusiness schema to your homepage with the properties listed above. It is a standard request and should not cost much (most developers will do it as a quick favor or charge $50 to $100 if it is a billable task).
Use a plugin if you are on WordPress. Yoast SEO, Rank Math, and Schema Pro all have schema generators built in. You fill out a form with your business info, the plugin writes the JSON-LD code, and it is added to your site automatically. No code editing required.
Use a website builder's embed/code block feature. Squarespace, Wix, Shopify, and most modern website builders let you add custom code blocks to pages. You generate the schema using a tool like Merkle's generator, copy the JSON-LD code, paste it into a code block on your homepage, and publish. The code block is treated as HTML and the schema is added to the page.
Work with us. If you are a Brattleboro Local client or considering working with us, LocalBusiness schema is part of our standard website build. We add it to every site we launch, test it, and make sure it matches your Google Business Profile. If you have an existing site and want schema added, we can do it as a standalone project (usually takes 15 to 30 minutes depending on complexity).
A West Dover bed and breakfast owner had a Squarespace site and no idea how to edit code. She used Merkle's schema generator to create LocalBusiness schema with her business name, address, phone, hours, price range, and logo. She copied the generated JSON-LD code, logged into Squarespace, added a "Code" block to her homepage (in the page editor, she clicked "Add Block" and selected "Code"), pasted the schema code into the block, and saved the page. She tested it in Rich Results Test, confirmed it was valid, and published. Total time: twelve minutes, no developer required.
How schema fits into the broader local SEO picture
Schema markup is one piece of local SEO. It is important, but it does not replace the other fundamentals. Here is how it fits into the bigger picture:
Google Business Profile: Your profile is the single most important local SEO signal. Claim it, verify it, fill it out completely, keep it updated, get reviews, respond to reviews. Schema reinforces your profile but does not replace it.
NAP consistency: Your business name, address, and phone should be identical everywhere they appear (Google profile, website, schema, citations, directories). NAP consistency is the foundation of local SEO. Schema is a tool to verify NAP, but if your NAP is inconsistent, schema will not fix it (and may make it worse if the schema has different information than your profile).
Reviews: Review volume, recency, and average rating are major ranking factors. Schema can display your rating in search results (if you have reviews on your site and mark them up with Review schema), but it does not generate reviews. You still need to ask customers for reviews consistently.
Website quality: A fast, mobile-friendly, well-structured website with clear service area and service type content is critical. Schema tells Google what your business is, but your website tells Google (and searchers) whether you are worth clicking on and calling.
Citations: Being listed on directories, review sites, and aggregators with consistent NAP builds authority. Schema on your website is one signal; citations across the web are another. Both matter.
Schema amplifies and clarifies the signals you are already sending. If you have a strong Google Business Profile, consistent NAP, good reviews, and a solid website, adding schema makes all of those signals stronger because Google can verify them with certainty. If you have weak signals or inconsistent information, schema will not fix the underlying problems (and may highlight them to Google, which hurts rather than helps).
A Brattleboro contractor had a complete local SEO foundation: verified Google Business Profile with 47 reviews (average 4.7 stars), consistent NAP across 30 citations, a fast custom-built website with service pages for each town he served, and active review requests after every job. He was ranking second or third in the map pack for most of his target searches. We added LocalBusiness schema to his homepage and Service schema to his service pages. Within a month he moved from third to second in two towns and from second to first in one town. The schema did not create his rankings (the foundation did that), but it gave Google the final verification signal it needed to push him over the edge in competitive searches.
The 15-minute schema setup checklist
If you want to add schema to your site today and you are starting from scratch, here is the fastest path:
Minute 1-3: Go to schema.org/LocalBusiness and review the list of properties. Decide which ones apply to your business (at minimum: name, address, phone, url; ideally also: hours, service area, logo, image).
Minute 4-7: Use Merkle's Schema Markup Generator (technicalseo.com/tools/schema-markup-generator/) or a similar tool. Fill in your business information. Copy the generated JSON-LD code.
Minute 8-10: Add the code to your website. If you can edit the HTML directly, paste it into the <head> section of your homepage. If you use WordPress, paste it into a Yoast or Rank Math schema field. If you use Squarespace/Wix, add a code block to your homepage and paste it there.
Minute 11-13: Publish the page. Go to search.google.com/test/rich-results and test your homepage URL. Review the results.
Minute 14-15: Fix any errors the test finds (usually missing commas, missing properties, or formatting issues). Re-publish, re-test, confirm it is valid.
Done. Your site now has LocalBusiness schema, Google can read it, and you are eligible for rich results and improved local rankings.
A Putney retail shop owner followed this checklist on a Saturday morning. She used Merkle's generator, filled in her business name, address, phone, hours, and logo URL, copied the code, pasted it into a code block on her Squarespace homepage, published it, and tested it in Rich Results Test. It was valid on the first try. Total time: fourteen minutes. Within three weeks Google started showing her hours in search results when people searched for her business name, and her click-through rate from search increased by about 10% (because searchers could see she was open before they clicked).
What to do this week
If your website does not have schema markup, you are leaving local SEO signal strength on the table. Here is the one-week plan:
Day one: Check if your site already has schema. View the source of your homepage (right-click, "View Page Source" in most browsers), and search (Ctrl-F or Cmd-F) for "schema.org". If you find a script tag with "@type": "LocalBusiness" or similar, you already have schema. Review it to make sure it is complete and accurate. If you do not find anything, move to day two.
Day two: Gather your business information. Write down your exact business name (as it appears on Google), address (formatted exactly as it appears on Google), phone number (formatted exactly as it appears on Google), hours, website URL, logo URL, and the towns you serve.
Day three: Generate your schema using Merkle's tool or write it manually. Test it in JSONLint to make sure the syntax is valid.
Day four: Add the schema to your homepage (via code, plugin, or code block depending on your platform). Publish the page.
Day five: Test the page in Rich Results Test. Fix any errors. Re-publish and re-test until it is valid.
Day six: If applicable, add Service schema to your service pages, or Review schema to pages with customer testimonials. Test those pages too.
Day seven: Request re-indexing of your homepage in Google Search Console (optional but speeds up the process). Then wait and monitor. Check back in two to four weeks to see if Google is displaying rich results or if your rankings have improved.
That is the plan. One week to set it up, then it is live forever and working in the background to verify your business information and strengthen your local SEO signals.
A Londonderry HVAC contractor followed this plan in the first week of April. By mid-April Google was displaying his hours in search results. By early May he had moved from fourth to third in the map pack for "HVAC Londonderry" and from not ranking to fifth for "furnace repair Windham County." By June his call volume was up 20% compared to the prior year, and when he asked new clients how they found him, several mentioned they saw his hours in search results and called during business hours instead of moving on to the next result. Schema did not transform his business overnight, but it removed friction, verified his details, and gave him a small ranking edge that compounded into more visibility and more calls.
Want to know if your site has schema, whether it is correct, and what else you can do to strengthen your local SEO foundation? The free 27-point local SEO audit we offer includes a schema check, NAP consistency analysis, Google Business Profile review, and a prioritized list of what to fix first. You will see exactly where you stand and what to do next. No pitch, just the diagnostic and the action plan.
Keep reading
Grafton's tourism economy and the invisible web: what happens when charm isn't online
Grafton's historic village businesses rely on foot traffic and reputation, but when out-of-state visitors search online or ask AI where to eat, stay, or shop, many don't exist digitally. That's lost revenue every single day.
How serving Townshend and Jamaica changes your website structure
A plumber serving both Townshend and Jamaica needs different website structure than one serving a single town. Here's how multi-location service coverage changes your site structure, schema markup, and local SEO strategy.
Do Guilford home-service businesses really need websites when Craigslist still works?
A Guilford plumber gets 90% of his leads from Craigslist and wonders why he would pay for a website. Here's what he's losing to competitors who show up when customers Google his name, and why the trust gap is costing him the high-value jobs.