Publish one LocalBusiness JSON-LD entity on the page that describes each location, using the most specific subtype that truthfully fits, such as Dentist or Restaurant. Copy the name, address, phone number and hours exactly as they appear on that page.

Confirm the visible facts first, pick the subtype, then check what your theme, plugin or platform already outputs so you do not add a second entity. After that, write the JSON-LD, place it on the location's page and test the live address.

Google says name and address are required for its Local Business feature, while phone, URL, coordinates, hours and price range are recommended. Markup describes your business to systems that read it. It does not create a Google Business Profile, and it does not promise a rich result, a ranking or a place in local results.

Key takeaways

  1. Choose the narrowest subtypeUse the most specific Schema.org subtype that truthfully fits, such as Dentist or Restaurant, and fall back to LocalBusiness only when none does.
  2. Match name, address and hoursCopy the name, address, phone and hours exactly as the location page shows them. Keep them consistent with the Google Business Profile.
  3. Know the required fieldsGoogle says name and address are required for its Local Business feature. Phone, URL, coordinates, hours and price range are recommended.
  4. Skip an invented addressA service-area business should not invent an address. Describe its territory with areaServed, which does not replace the address Google's Local Business feature requires.
  5. Check existing output firstSearch the live page for application/ld+json and edit any existing business block. Two entities with different names or hours give a reader two answers.
  6. Test, then keep it currentTest the published URL, which confirms syntax or eligibility but not a rich result, ranking or local placement. Update the markup when hours, phone or address change.

What LocalBusiness schema describes

LocalBusiness is a Schema.org type for a physical business or branch. Schema.org is a shared vocabulary of types and properties, and JSON-LD is the JSON-based format that carries it, usually inside a script tag in the page HTML. Google recommends JSON-LD and says structured data must represent the content visible on the page (Google general structured data guidelines; W3C JSON-LD 1.1).

Google says LocalBusiness data can help it understand business hours, departments and related details. Google Search may show business details in a knowledge panel or other business-related features, but whether it does depends on Google's systems and on the person searching (Google Local Business structured data).

The markup can clarify which business a page is about and connect its name, address, hours, phone, URL and coordinates. It cannot make a hidden fact eligible, change the page's text or design, or turn a service-area business into a storefront.

Choose the most specific subtype

Start from the narrowest Schema.org type that truthfully describes the business. A noodle restaurant is a Restaurant, a family dentist is a Dentist, and a shop that sells goods can be a Store. Schema.org lists many more, and the LocalBusiness type page shows the whole tree.

Common subtypes include:

  • Restaurant, Bakery, CafeOrCoffeeShop and BarOrPub for food and drink
  • Dentist, Physician and MedicalClinic for health care
  • AutoRepair, DaySpa and HealthClub for services
  • Attorney, FinancialService and RealEstateAgent for professional offices
  • Hotel, LodgingBusiness and TravelAgency for travel
  • Store and Library for places people visit

If no specific subtype fits, use LocalBusiness itself. When several types accurately describe the same entity, Google documents an array of types, such as ["Electrician", "Plumber", "Locksmith"]. Do not use additionalType for that purpose. Because LocalBusiness is a subtype of Organization, Google also recommends following its Organization fields; the Organization schema guide covers them.

Confirm the name, address, phone and hours on the page

Consider a restaurant owner standing at the front counter after closing, laptop open, comparing the hours printed on the door with the hours on the website. That comparison is the real first step. The markup should repeat what visitors can already read on the page, and what the Google Business Profile shows.

A grey-haired restaurant owner in an apron stands at the front counter after closing, looking at a laptop beside a handwritten hours card
Figure 1. Compare the hours on the door with the hours on the website before writing any markup.

Google Business Profile and website markup do different jobs. The profile controls the business information managed in Google Maps and Google Search, and a verified profile is not created by adding schema. Your JSON-LD describes what is on a webpage. Keep the business name, address, phone number, hours, service area and URL consistent between the two, and write the name the way customers see it, not a keyword-filled version.

For the address, use PostalAddress with streetAddress, addressLocality, addressRegion, postalCode and addressCountry. Schema.org recommends a two-letter ISO 3166-1 country code such as US (Schema.org PostalAddress). For the phone number, use the primary customer line with country and area code. For coordinates, use GeoCoordinates with decimal latitude and longitude. Google recommends at least five decimal places, and the point should be the actual business location, not a city center or an unrelated office (Schema.org GeoCoordinates).

Write the JSON-LD for one location

The example below is a complete entity for one fictional restaurant on reserved example domains. Replace every value with the facts from your own page, keep the @type you chose in the subtype step, and give @id a stable URL for this location. The servesCuisine property fits food businesses; delete it if it does not apply.

json
{
  "@context": "https://schema.org",
  "@type": "Restaurant",
  "@id": "https://www.example.com/locations/riverside/#localbusiness",
  "name": "Example Noodle House",
  "url": "https://www.example.com/locations/riverside/",
  "telephone": "+1-555-010-0142",
  "image": "https://www.example.com/images/storefront.jpg",
  "description": "A family noodle restaurant serving soups, rice plates and tea.",
  "servesCuisine": "Vietnamese",
  "priceRange": "$$",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "123 Example Avenue",
    "addressLocality": "Exampletown",
    "addressRegion": "IL",
    "postalCode": "60000",
    "addressCountry": "US"
  },
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": 41.12345,
    "longitude": -87.12345
  },
  "openingHoursSpecification": [
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Tuesday", "Wednesday", "Thursday", "Friday"],
      "opens": "11:00",
      "closes": "21:00"
    },
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Saturday", "Sunday"],
      "opens": "10:00",
      "closes": "20:00"
    }
  ],
  "sameAs": [
    "https://social.example.org/example-noodle-house"
  ]
}

For this Google feature, name and address are required. The properties url, telephone, geo, openingHoursSpecification and priceRange are recommended. The properties image, logo, description, sameAs and @id are valid Schema.org properties that add identity details, and they are optional for this feature. Keep review and aggregateRating out of your own business markup unless the page shows genuine reviews and meets Google's review policies; the review schema guide explains those rules. For more worked samples, see the JSON-LD schema examples.

If you would rather fill in a form than edit code, the LocalBusiness schema generator builds the same structure from the details you enter.

Mark up overnight and seasonal hours

Use OpeningHoursSpecification for structured hours. Set dayOfWeek to Monday through Sunday, and write opens and closes as 24-hour hh:mm values. Add one entry for each block of days that share the same hours, and make sure the result matches the hours written on the page and in the Business Profile.

Overnight hours can use a closing time earlier than the opening time, such as 18:00 to 03:00. Use 00:00 to 23:59 for all-day opening. For seasonal hours, use both validFrom and validThrough on the entry. Schema.org also supports the compact openingHours string, but openingHoursSpecification is clearer when days, overnight periods or seasons differ (Schema.org OpeningHoursSpecification).

This array is valid JSON and replaces the value of openingHoursSpecification in the main example. It shows a late Friday service that closes after midnight and a summer period with longer evening hours. Change the dates and times to your own.

json
[
  {
    "@type": "OpeningHoursSpecification",
    "dayOfWeek": "Friday",
    "opens": "18:00",
    "closes": "03:00"
  },
  {
    "@type": "OpeningHoursSpecification",
    "dayOfWeek": ["Saturday", "Sunday"],
    "opens": "10:00",
    "closes": "22:00",
    "validFrom": "2026-06-01",
    "validThrough": "2026-07-15"
  }
]

For a one-day holiday change, use the special-hours method on the platform or profile you manage, and update the page text at the same time so the visible hours stay current.

Describe a storefront or a service-area business

A storefront is a place customers visit, so it uses address and geo, and it can add areaServed when it also serves a wider region. A service-area business travels to its customers. Google's Business Profile guidance says such a business should not publish a customer-facing address unless customers actually visit that address, and it should set its service area in the profile.

Describe that area with areaServed, which can hold a place, an administrative area, a geographic shape or plain text (Schema.org areaServed). One limit matters here: areaServed does not replace the physical address that Google's Local Business feature requires. A mobile business without a public address can still publish accurate markup with the other properties, but it should not invent an address to meet the feature. Replace the names and URLs in this fictional example.

json
{
  "@context": "https://schema.org",
  "@type": "Locksmith",
  "@id": "https://www.example.com/#localbusiness",
  "name": "Example Mobile Locksmith",
  "url": "https://www.example.com/",
  "telephone": "+1-555-010-0177",
  "description": "A mobile locksmith that travels to homes and cars.",
  "areaServed": [
    { "@type": "City", "name": "Exampletown" },
    { "@type": "City", "name": "Sampleville" }
  ]
}

Each physical location gets its own entity on its own page. A homepage-wide entity that stands in for several branches is a common mistake, and the multiple locations guide covers how to structure them. A separate department with its own details can be nested under the parent business with the department property.

Check what your site already outputs

Before you paste anything in, find out whether the page already carries a business entity. Open the live page, view the source and search for application/ld+json. A Rich Results Test run on that URL shows the same blocks. A theme, an SEO plugin or the platform itself may already print a LocalBusiness or Organization block.

If one exists, edit it rather than adding a second. Two entities for the same business, with slightly different names or hours, give a reader of the markup two answers. Fix the existing block where the platform lets you, or turn its output off before you add your own.

Two horizontal time bars, one daytime and one running past a crescent moon into the early morning, with a small seasonal tag
Figure 2. Hours that cross midnight and seasonal periods each need their own entry.

Platform output differs, so confirm it for your own site. Wix says it can add Local Business markup automatically and also lets you add JSON-LD by hand (Wix structured data markup). Shopify's SEO documentation describes built-in theme structured data and SEO controls (Shopify SEO overview). Both pages are worth reading before you add custom code.

Add the JSON-LD on WordPress, Shopify, Wix, Squarespace, Webflow or custom code

Place the markup on the page that describes the location, not on every page. Each platform has its own route, and its current documentation is the authority for menus and plan limits.

On WordPress, an SEO or schema plugin that supports custom JSON-LD for a single page, or a snippet in a child theme, are the usual routes; the WordPress schema guide walks through them. On Shopify, check the theme's built-in output first, then follow Shopify's current theme documentation if you edit a template. On Wix, use the manual JSON-LD option for the page, after checking the automatic Local Business markup. On Squarespace and Webflow, look in the current documentation for the page-level custom code area, and confirm that your plan includes it.

On a hand-built site, put a script element in the head or body of the location's page. The element wraps the same JSON, shown here in its smallest valid form with only the two properties Google requires for this feature.

html
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Restaurant",
  "name": "Example Noodle House",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "123 Example Avenue",
    "addressLocality": "Exampletown",
    "addressRegion": "IL",
    "postalCode": "60000",
    "addressCountry": "US"
  }
}
</script>

Paste the full entity from your own build between the tags. The how to add schema markup guide compares installation routes in more detail.

Setup steps in order

Testing confirms syntax or eligibility signals. It does not guarantee that a search result will appear.

  1. Choose the subtypePick the most specific type that truthfully fits, or LocalBusiness when none does.
  2. Confirm visible factsMatch name, address, phone and hours to the page and the Business Profile.
  3. Write the JSON-LDUse valid JSON with one entity for this location.
  4. Place it on the location pageCheck existing theme or plugin output first, then add the markup.
  5. Test the live URLRun the Rich Results Test, the Schema.org Validator and URL Inspection.
  6. Maintain changesUpdate the markup whenever hours or contact details change.

Test the live page with each provider's tools

Run the published URL, not only the code in a draft, through Google's Rich Results Test and the Schema.org Validator. The first reports whether the page is eligible for a Google feature, and the second checks the markup against the Schema.org vocabulary. Then use URL Inspection in Search Console to look at the live address as Google fetched it.

For Bing, the URL Inspection tool includes a Markup card that recognizes JSON-LD and reports markup issues. Yandex offers a structured data validator that supports Schema.org, Open Graph, Microdata, RDFa and Microformats. Apple's App Search documentation describes a validation tool for its search APIs, where it applies to your setup.

A passing result confirms syntax, recognized properties or feature eligibility. It does not guarantee a rich result, a ranking or local placement. Also confirm that robots.txt and page settings do not block the page or its resources, since Google says markup must be on an indexable page.

Bing supports Schema.org in JSON-LD and Microdata, so the same block serves both Google and Bing (Bing structured data markup). Microsoft says web-enabled Copilot can use Bing results to ground its answers (Microsoft Copilot web search), so keep key details in visible text. Google says AI Overviews and AI Mode need no special structured data beyond normal Search eligibility (Google AI features and your website); that is no reason to drop valid markup.

If you want ChatGPT Search to reach the page, allow OAI-SearchBot in robots.txt (OpenAI, ChatGPT Search); PerplexityBot follows robots.txt (Perplexity, 2025). Yandex says markup can support snippets (Yandex semantic markup questions). For all of them, publish accurate visible details, valid JSON-LD and a crawlable, indexable page. See whether AI systems use schema markup.

Keep the markup current

Update the JSON-LD whenever the hours, phone number, address or name change, and change the visible page and the Business Profile in the same sitting. Markup that disagrees with the page is a common error, along with invalid JSON, comments, trailing commas, single quotes and duplicate keys. Retest after each edit and after any theme or plugin update that could add its own block.

Questions people ask

Does LocalBusiness schema improve rankings?

Google says structured data enables a feature but does not guarantee that the feature will appear. The markup helps systems understand the page, and no provider promises a ranking, traffic or a citation from it. Use it to describe the business accurately.

Do I need latitude and longitude?

No. Google lists geo as recommended for its Local Business feature, not required. If you include it, use at least five decimal places and the real business location.

Can I add the markup to every page?

Add it to the page that describes the location. Markup on a page that does not describe that business location is a common error. A single-location site often has a location or contact page, and sitewide organization details are covered in the Organization schema every page guide.

Should I add review or rating markup?

Only when the page shows genuine reviews and follows Google's review policies. Google's general guidelines restrict fake and self-serving reviews, so never invent a rating to fill a property.

Quick check

Choose an answer to see feedback. Nothing is scored or saved.

Question 1 of 3

Which two properties does Google require for its Local Business feature?

Question 2 of 3

A mobile locksmith has no public storefront. What matters first?

Question 3 of 3

A validator reports valid JSON-LD. What does that show?

Local business schema terms

Select a term to see its definition.

LocalBusiness. A Schema.org type for a physical business or branch.