Schema markup for local businesses: what it is, why it matters, and how to add it

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. You become more likely to show up in local searches and appear in rich results, and 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 and knows exactly what it means, so it 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). When Google crawls your page, it reads the structured data in that script 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.

For example, say a Putney contractor adds LocalBusiness schema to his homepage in JSON-LD format. The schema includes his business name, address, phone, hours, service area (Windham County towns), and a link to his logo. He tests it in Google's Rich Results Test (more on that below), confirms it is valid, and publishes it. Google may start displaying his hours directly in search results when people search for his business name, and it can now confirm his NAP and service area from structured data instead of inferring them from page text. That can help where he is borderline in the map pack, though schema alone guarantees nothing.

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 makes your business more likely to show up for relevant searches and rank well in the map pack. It also improves your odds of appearing 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.

Picture a Bellows Falls retail shop that adds schema to its homepage with its business name, address, phone, and hours. The schema address is "123 Depot Street, Bellows Falls, VT 05101." The Google Business Profile address is "123 Depot St, Bellows Falls, VT 05101" (abbreviated "St" instead of spelled-out "Street"). The inconsistency is minor, but it is still an inconsistency. Updating the schema to match the Google profile exactly (abbreviated "St") aligns the signal, so Google can 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 from 9 a.m. to 5 p.m. If your hours differ by day 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"
}

To find your coordinates, search for your address on Google Maps and right-click the location pin. Then select "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.

For example, a Wilmington cleaning service might add LocalBusiness schema to its homepage with all the core properties: name, address, phone, hours, service area (Wilmington, West Dover, Dover, Marlboro), price range ($$), logo, and geo coordinates, then test it in Rich Results Test, confirm it is valid, and publish it. If Google starts showing the hours in search results for "cleaning service Wilmington VT," searchers can see the business is open before they even click, which tends to help click-through.

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 and the one Google crawls most frequently. It is also 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, your developer can add it directly to the template.

For example, say a Townshend contractor has a custom-built site. His developer adds LocalBusiness schema to the homepage template as a script tag in the <head>, with his business name, address, phone, hours, service area (Townshend, Grafton, Londonderry, Jamaica, Windham), logo, and geo coordinates. The code is about 20 lines and takes a few minutes to add. From then on, every time Google crawls his homepage, it reads that schema and confirms his business details.

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 } and every opening bracket [ has a matching closing bracket ]. Every property except the last one in an object also needs 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 and the tool crawls the page. Then 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.

Say a Londonderry electrician uses Merkle's schema generator to create his LocalBusiness schema. He fills in his business name, address, phone, hours, service area, and logo URL. The tool generates the JSON-LD code. He copies it, logs into his website (a basic HTML site his nephew built years ago), opens the homepage file, pastes the schema code into the <head> section, and saves it. He tests it in Rich Results Test, sees that it is valid with no errors, and calls it done. It is about a ten-minute job.

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.

For example, a Brattleboro bookkeeper adds LocalBusiness schema to her homepage and tests it in Rich Results Test. She gets an error: "Missing field 'address.addressRegion'." She included the street address, city, and ZIP code, but forgot the state abbreviation. She adds "addressRegion": "VT" to the schema, re-publishes the page, tests again, and gets a green checkmark. The schema is now valid and Google can read it.

Common schema mistakes and how to avoid them

Most schema errors are formatting mistakes or missing required properties. Here are the most common ones:

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 or extra comma, mismatched brackets, 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 into JSONLint and click "Validate JSON." 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 and sees the conflict, so it 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.

Here is what skipping the test costs. Say a Putney contractor adds LocalBusiness schema to his homepage and does not test it. Months later he discovers the schema has a syntax error (a missing closing brace) and Google has been unable to read it the whole time. He fixes the error, tests it, confirms it is valid, and re-publishes. Those months were wasted 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.

For example, picture a Bellows Falls mobile mechanic with 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, instead of inferring his service area 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.

Keep expectations realistic. Say a Newfane landscaper adds LocalBusiness schema to his homepage. Google may start displaying his hours in search results for his business name within weeks. Any ranking movement in the towns where he is borderline will be gradual, and it will be hard to separate the effect of the schema from consistent review growth and NAP consistency fixes made around the same time. Schema alone does not transform a business, but it is one piece of a broader local SEO strategy that compounds 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.

For example, a Brattleboro law firm could add LocalBusiness schema to its homepage and Service schema to its practice area pages (estate planning, real estate law, family law, etc.). Each service page gets its own Service schema block with the service name, description, provider (the law firm), and areaServed (Windham County). The combination of LocalBusiness schema (verifying the firm's NAP and location) and Service schema (clarifying exactly what services it offers) gives Google explicit signals that match queries like "estate planning lawyer Brattleboro" and "real estate attorney Windham County."

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. Its website has a locations page with all three addresses, and separate detail pages for each office (example.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.

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 and the plugin writes the JSON-LD code, which 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.

Start from a site that states the facts plainly. If you do not have a website yet, Brattleboro Local writes and builds a six-page site for your business (home, about, services, one page for the areas you cover, common questions, and contact) on your own domain, for $499 a year with hosting, security and backups included. Your name, address and phone number are stated plainly, and you can change them yourself with your login. Custom code and schema tuning are not part of that product, so if you want schema beyond the basics, use one of the options above. See the details.

For example, say a West Dover bed and breakfast owner has a Squarespace site and no idea how to edit code. She uses Merkle's schema generator to create LocalBusiness schema with her business name, address, phone, hours, price range, and logo. She copies the generated JSON-LD code and logs into Squarespace. On her homepage she adds a "Code" block (in the page editor, "Add Block," then "Code"). She pastes the schema code into the block and saves the page. She tests it in Rich Results Test, confirms it is valid, and publishes. A few 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) if 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).

Picture a Brattleboro contractor with a complete local SEO foundation. He has a verified Google Business Profile with plenty of reviews and consistent NAP across his citations. His fast website has service pages for each town he serves, and he actively requests reviews after every job. He is already ranking second or third in the map pack for most of his target searches. Adding LocalBusiness schema to his homepage and Service schema to his service pages will not create rankings (the foundation does that), but it gives Google one more clear verification signal in competitive searches where the margins are thin.

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 that Google can read, and you are eligible for rich results and improved local rankings.

For example, a Putney retail shop owner could work through this checklist on a Saturday morning: use Merkle's generator, fill in her business name, address, phone, hours, and logo URL, copy the code, paste it into a code block on her Squarespace homepage, publish it, and test it in Rich Results Test. If it is valid on the first try, the whole job takes about a quarter of an hour. If Google then shows her hours in search results, searchers can see she is open before they click.

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 and choose "View Page Source" in most browsers). Then 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.

Say a Londonderry HVAC contractor follows this plan. Google may start displaying his hours in search results within a few weeks, and over time the schema helps confirm his details for searches like "HVAC Londonderry" and "furnace repair Windham County." When he asks new clients how they found him, some may mention seeing his hours in search results and calling during business hours instead of moving on to the next result. Schema does not transform a business overnight, but it removes friction, verifies details, and adds a small edge that compounds over time.

Want to know if your site has schema and whether it is correct? Paste your homepage address into Google's free Rich Results Test and you will see exactly what Google reads. If you need a website to start from, Brattleboro Local writes and builds a six-page site for your business for $499 a year, hosting included, with a login so you can keep your details current. See the details.