Local Business Schema: How to Set It Up and Help Google Understand Your Business

LocalBusiness schema is structured data that tells search engines the facts about a physical business – its name, address, phone, opening hours and location. Google requires only two properties: name and address; everything else (telephone, geo coordinates, openingHoursSpecification, url, priceRange) is recommended and adds precision. Write it in JSON-LD, use the most specific subtype available (Plumber, Dentist, Restaurant) rather than generic LocalBusiness, and make every detail match your Google Business Profile exactly. One honest caveat: schema does not get you into the local map pack – your Google Business Profile does that. Schema’s job is making sure Google and AI assistants hold the same unambiguous facts about you.

If your business has a location – a shop, a clinic, an office, or a van that drives to customers – Google needs to understand three things: who you are, where you are, and when you’re open. LocalBusiness schema states those facts in a format machines can’t misread, instead of leaving them to be inferred from a footer.

This is the dedicated treatment of the type flagged as one of the highest-impact in the technical SEO strategies guide on GrowWithSakib. If you’re new to structured data generally, start with the schema markup guide for beginners on GrowWithSakib, which covers JSON-LD, validation and the types that still earn rich results – and what technical SEO actually is on GrowWithSakib for the wider groundwork.

What LocalBusiness Schema Does – and What It Doesn’t

Most local schema guides claim that adding LocalBusiness markup makes you “eligible for Google’s local pack.” It doesn’t. The local pack – that three-result map block – is populated from Google Business Profile data, not from markup on your website. No amount of schema will place you in it, and no schema edit will fix a ranking problem that lives in your profile.

What LocalBusiness schema actually does is quieter and still worth doing: it confirms your business entity to Google in unambiguous terms, reinforces the consistency between your website and your profile, supports rich presentation of your organic listing, and – increasingly important – gives AI assistants accurate structured facts to quote when someone asks about your business.

Hold that distinction and you’ll spend your effort in the right places: your Google Business Profile for map-pack visibility, and schema for entity clarity across search and AI. They reinforce each other, but they aren’t substitutes.

The Properties: What Google Actually Requires

Google’s LocalBusiness documentation is refreshingly minimal about requirements. Most guides bury this:

PropertyStatusWhat It Does
nameREQUIREDYour business name, exactly as it appears on your profile
addressREQUIREDA PostalAddress object with the location details
telephoneRecommendedContact number in international format (+971-…)
geoRecommendedLatitude and longitude – the precise map point
openingHoursSpecificationRecommendedStructured opening hours, including seasonal variations
urlRecommendedYour website, or the specific location page
image / logoRecommendedVisual assets for richer presentation
priceRangeRecommendedRough price indication, e.g. $$ or AED 200-500
sameAsRecommendedLinks to your authoritative profiles – the entity lever
areaServedSituationalThe regions you serve – essential for service-area businesses

Google explicitly asks you to “use the most specific LocalBusiness sub-type possible.” So a plumbing company should use Plumber, not LocalBusiness; a dental practice Dentist; a cafe CafeOrCoffeeShop. The more specific the type, the more precisely Google understands what you do.

It’s also worth knowing that LocalBusiness is a subtype of both Organization and Place – so it inherits properties from both, and Google recommends following the Organization guidance alongside it. Browse the full subtype list on Schema.org before defaulting to the generic type.

Recommended Hosting Partner

Is Your WordPress Hosting Ready for SEO Growth?

Choose a reliable hosting foundation that supports website performance, security, and long-term SEO growth.

  • WordPress Hosting
  • SSL Included
  • 24/7 Support
  • Reliable Speed
Explore Hostinger
Affiliate disclosure: We may earn a commission at no extra cost to you.

The Standard Markup

Here’s a complete, copyable LocalBusiness block using a specific subtype, with the recommended properties filled in:

<script type=”application/ld+json”>
{
“@context”: “https://schema.org”,
“@type”: “Dentist”,
“@id”: “https://example.com/#business”,
“name”: “Bright Smile Dental”,
“url”: “https://example.com”,
“telephone”: “+44-161-555-0100”,
“priceRange”: “$$”,
“address”: {
“@type”: “PostalAddress”,
“streetAddress”: “12 High Street”,
“addressLocality”: “Manchester”,
“postalCode”: “M1 2AB”,
“addressCountry”: “GB”
},
“geo”: {
“@type”: “GeoCoordinates”,
“latitude”: 53.4808,
“longitude”: -2.2426
},
“openingHoursSpecification”: [{
“@type”: “OpeningHoursSpecification”,
“dayOfWeek”: [“Monday”,”Tuesday”,”Wednesday”,”Thursday”,”Friday”],
“opens”: “09:00”,
“closes”: “17:30”
}],
“sameAs”: [
“https://www.facebook.com/example”,
“https://maps.google.com/?cid=YOUR_GBP_ID”
]
}
</script>

Two details worth noting. The @id gives your business a stable identifier that other schema blocks on your site can reference, which keeps your entity coherent across pages. And sameAs is the entity lever – listing the authoritative profiles you own (including your Google Maps listing) helps Google consolidate them into one business rather than several.

Addresses Where There Is No Postal Code: The UAE Example

Most schema tutorials assume a US or UK address and treat postalCode as a given. That assumption breaks across much of the Gulf. The UAE operates no federal postal code system, and no emirate uses one – mail is routed through PO Boxes, and precision comes from building identifiers instead.

When a shipping form demands a postcode, UAE residents type 00000. That’s a sensible workaround for a form – but it is not a schema value. Putting 00000 in structured data asserts a postal code that doesn’t exist, which conflicts with the core rule that markup must describe reality.

Since postalCode is not a required property, the correct approach is simply to omit it. Your markup stays valid, and you’ve stated nothing false.

Which makes geo-coordinates far more important here than in London or Chicago. With no postcode to narrow the location, the geo object becomes your primary precision signal. In Dubai you also have the Makani number – a 10-digit code assigned by Dubai Municipality to every building, identifying a single entrance far more precisely than any postal district. There’s no dedicated Schema.org property for it, so include it in the street address or as an additional property.

<script type=”application/ld+json”>
{
“@context”: “https://schema.org”,
“@type”: “ProfessionalService”,
“name”: “Gulf Interiors Studio”,
“telephone”: “+971-4-555-0100”,
“address”: {
“@type”: “PostalAddress”,
“streetAddress”: “Office 1204, Boulevard Plaza Tower 1”,
“addressLocality”: “Downtown Dubai”,
“addressRegion”: “Dubai”,
“addressCountry”: “AE”
},
// No postalCode – the UAE has no postal code system.
// Geo coordinates carry the precision instead.
“geo”: {
“@type”: “GeoCoordinates”,
“latitude”: 25.1972,
“longitude”: 55.2744
},
“openingHoursSpecification”: [{
“@type”: “OpeningHoursSpecification”,
“dayOfWeek”: [“Sunday”,”Monday”,”Tuesday”,”Wednesday”,”Thursday”],
“opens”: “09:00”,
“closes”: “18:00”
}]
}
</script>

addressRegion is the emirate – Dubai, Abu Dhabi, Sharjah. addressLocality is the community or area, such as Downtown Dubai, Business Bay or Al Barsha.

Working weeks differ. Many UAE businesses run Monday-Friday, but plenty still operate Sunday-Thursday. Your openingHoursSpecification should reflect what you actually do, not a Western default – this is exactly the kind of detail an AI assistant will repeat to a customer.

Use international phone format – +971-4-555-0100 – so the number is unambiguous to every parser.

Service-Area Businesses: When You Have No Storefront

Plumbers, electricians, mobile groomers, consultants who visit clients – businesses that serve customers at their location rather than their own. The property for this is areaServed, which can name a city, an administrative area, or a defined geographic shape.

<script type=”application/ld+json”>
{
“@context”: “https://schema.org”,
“@type”: “Plumber”,
“name”: “Rapid Response Plumbing”,
“telephone”: “+971-4-555-0199”,
“url”: “https://example.com”,
“areaServed”: [
{ “@type”: “City”, “name”: “Dubai” },
{ “@type”: “City”, “name”: “Sharjah” }
],
“openingHoursSpecification”: [{
“@type”: “OpeningHoursSpecification”,
“dayOfWeek”: [“Monday”,”Tuesday”,”Wednesday”,”Thursday”,”Friday”,”Saturday”,”Sunday”],
“opens”: “00:00”,
“closes”: “23:59”
}]
}
</script>

Don’t declare a storefront address and a tight service radius at the same time. That combination sends contradictory signals – a storefront claiming to be mobile, or a mobile business claiming a walk-in location. Pick the mode that matches your business and stay consistent with how you’ve configured your Google Business Profile.

Two more practical points: if you operate outside standard hours – emergency call-outs, 24/7 response – declare it in openingHoursSpecification, because that’s a real differentiator machines can act on. And if you hide your address on your profile because you work from home, don’t publish it in schema either.

Connecting Schema to Your Google Business Profile

These are two separate systems – editing schema won’t update your profile, and updating your profile won’t change your website’s markup. What links them is consistency, and that consistency is genuinely valuable because it removes any doubt that the website and the profile describe the same business.

  • Match your NAP exactly. Name, address and phone should be character-identical to your profile. Even small differences – “St.” versus “Street”, a differently formatted phone number – introduce ambiguity you don’t need. Copy the formatting from your profile into your schema, not the other way round.
  • Use sameAs to point at your listing. Include your Google Maps URL among your sameAs profiles, so the entity behind your website and the entity behind your listing are explicitly the same one.
  • Keep citations aligned too. Directories and listings elsewhere should carry the same details – the same discipline covered in local citation building on GrowWithSakib.
  • One block per location. Multi-location businesses need a separate LocalBusiness block on each location page, not one combined block listing every branch.

A clinic came to us frustrated. They’d invested in detailed LocalBusiness schema – subtypes, geo coordinates, structured hours, the lot – specifically because an agency had promised it would get them into the map pack for their area. Months later, nothing had moved.

The schema was excellent. It was also irrelevant to their actual problem. Their Google Business Profile listed a category that didn’t match their main service, their address had never been verified after a move, and they had a fraction of the reviews their competitors held. The map pack draws on the profile, so the profile was where the problem lived – and no markup on their website could reach it.

We fixed the profile: corrected category, re-verified the address, and built a genuine review process. The map-pack visibility followed. We kept the schema exactly as it was, because it was doing its own job well – making sure their business facts were unambiguous everywhere else. The lesson was about matching the tool to the problem.

Validating and Maintaining Your Markup

A restaurant client changed their winter opening hours, updated their Google Business Profile carefully, and told their team. Weeks later, customers were still turning up an hour before opening and finding the doors locked.

The old hours were still hard-coded in the LocalBusiness schema on their website, left over from the previous season. Their profile said one thing; their markup said another. Anything reading the site directly – including AI assistants answering ‘what time does it open?’ – was confidently repeating the stale figure, and customers trusted it.

We corrected the markup and added a simple rule to their seasonal checklist: when the hours change, they change in three places – the profile, the website content, and the schema. Structured data is a promise about reality, and an out-of-date promise is worse than none, because machines repeat it with total confidence.

Local Schema and AI Assistants

There’s a 2026 reason to keep this markup accurate that didn’t exist a few years ago. When someone asks an AI assistant whether you’re open, where you are, or whether you cover their area, the assistant draws on the structured facts it can find. Clean LocalBusiness markup gives it unambiguous answers; stale or missing markup leaves it guessing or repeating something wrong. Schema isn’t a magic AI lever – as covered in the generative engine optimisation guide on GrowWithSakib – but for factual, checkable details like hours and location, it’s exactly the kind of clarity machines rely on.

Common Local Business Schema Mistakes

MistakeWhy It HurtsDo This Instead
Expecting schema to win the local packThe map pack comes from Google Business ProfileFix the profile for map visibility
Using generic LocalBusinessLoses precision Google explicitly asks forUse the most specific subtype available
NAP that differs from your profileAmbiguity about whether it’s one businessCopy the profile’s exact formatting
Putting 00000 as a UAE postal codeAsserts a code that doesn’t existOmit postalCode; it isn’t required
Storefront address plus tight service radiusContradictory signals about your modelPick one mode and stay consistent
Leaving stale opening hours in codeAI assistants confidently misinform customersUpdate schema whenever details change
One schema block for many locationsGoogle can’t separate the branchesOne LocalBusiness block per location page
Publishing a home address you hide on GBPExposes what you deliberately kept privateUse areaServed without the address

Want Your Business Facts Right Everywhere Google Looks?

Local visibility falls apart in the gaps: schema that contradicts your Google Business Profile, opening hours updated in one place but not the other, a service-area business marked up as a storefront, or effort poured into markup when the real problem sits in the profile. Each one quietly costs you customers who couldn’t confirm you were open, nearby, or right for the job.

At GrowWithSakib, we get the whole local picture consistent – accurate LocalBusiness markup with the right subtype and properties, aligned to your profile and citations, so search engines and AI assistants describe your business the same correct way.

Frequently Asked Questions

What is LocalBusiness schema markup?

LocalBusiness schema is structured data – usually written in JSON-LD – that states the facts about a physical business in a format search engines can’t misread: its name, address, phone number, opening hours, geographic coordinates and the areas it serves. It’s a subtype of both Organization and Place in the Schema.org vocabulary, so it inherits properties from both. Its purpose is entity clarity: making sure Google, other search engines, and AI assistants all hold the same unambiguous understanding of who your business is and where it operates.

Which properties does Google require for LocalBusiness schema?

Google requires only two: name and address. Everything else is recommended rather than mandatory. That said, the recommended properties are where most of the value sits – telephone, geo coordinates, openingHoursSpecification, url, image, priceRange and sameAs all add precision and make your business easier for machines to describe accurately. Google also asks you to use the most specific LocalBusiness subtype available, such as Plumber, Dentist or Restaurant, rather than the generic LocalBusiness type, because specificity helps it understand what you actually do.

Does LocalBusiness schema help me rank in the local pack?

No – and this is the most common misconception in local SEO. The local pack, the three-result map block, is populated from Google Business Profile data, not from markup on your website. No amount of schema will place you there, and no schema edit fixes a ranking problem that lives in your profile. What LocalBusiness schema does is confirm your business entity in unambiguous terms, reinforce consistency between your site and your profile, and give AI assistants accurate facts to quote. Use your profile for map visibility and schema for entity clarity.

How do I connect my schema to my Google Business Profile?

They’re separate systems, so there’s no direct connection – editing schema won’t update your profile, and vice versa. What links them is consistency. Make your name, address and phone character-identical to what’s on your profile, since even differences like ‘St.’ versus ‘Street’ introduce needless ambiguity. Then include your Google Maps listing URL in your schema’s sameAs array, which explicitly ties the entity behind your website to the entity behind your listing. Copy the formatting from your profile into your schema, not the other way round.

What postal code should I use in schema for a UAE business?

None – omit the property entirely. The UAE operates no federal postal code system and no emirate uses one, so there is no genuine value to supply. The ‘00000’ placeholder people type into shipping forms is a workaround for forms that demand a value; it is not a schema value, and putting it in structured data asserts a postal code that doesn’t exist. Since postalCode isn’t a required property, omitting it keeps your markup both valid and truthful. Use geo coordinates instead, since they carry the precision a postcode would elsewhere.

How do I mark up a business with no storefront?

Use the areaServed property to declare the geographic areas you cover, specified as cities, administrative areas or defined geographic shapes, and choose the most specific subtype for your trade such as Plumber or Electrician. Avoid declaring a full storefront address alongside a tight service radius, because that combination signals a contradiction about your business model. Keep it consistent with how your Google Business Profile is configured – if you hide your address there because you work from home, don’t publish it in your schema either.

Should each location have its own schema block?

Yes. Multi-location businesses need a separate LocalBusiness block on each location’s own page, with that location’s specific address, phone number, coordinates and hours – not one combined block attempting to list every branch. Give each a stable @id so other markup can reference it unambiguously. If you have a parent brand above the individual locations, model that with Organization schema and connect the locations to it, so the structure of your markup mirrors the actual structure of your business.

How often should I update my local business schema?

Whenever the underlying facts change – opening hours, phone number, address, seasonal schedules, or the areas you serve. This matters more than it used to: stale markup doesn’t just sit there harmlessly, it actively misinforms. AI assistants and search features read those structured facts and repeat them with complete confidence, so old opening hours left in your code will send customers to a closed door even if your Google Business Profile is perfectly up to date. Add schema to the same checklist you use when updating your profile.

Key Takeaways

  • LocalBusiness schema states your business facts – name, address, phone, hours, coordinates – in a form machines can’t misread. It’s about entity clarity, not rankings.
  • It does NOT get you into the local map pack. That comes from your Google Business Profile. Use the profile for map visibility and schema for factual clarity.
  • Google requires only two properties: name and address. Everything else is recommended – but that’s where most of the practical value sits.
  • Use the most specific subtype Google asks for – Plumber, Dentist, CafeOrCoffeeShop – rather than the generic LocalBusiness type.
  • Match your NAP to your Google Business Profile character for character, and use sameAs (including your Maps URL) to tie the entities together.
  • In the UAE there is no postal code system, so omit postalCode rather than inventing 00000 – and let geo coordinates carry the precision instead.
  • Service-area businesses should use areaServed, and should not declare a storefront address alongside a tight service radius – pick one mode.
  • Stale markup is worse than none: AI assistants repeat old opening hours with total confidence, so update schema whenever the facts change.