LocalBusiness vs Place vs Restaurant: Schema.org Type for AI
LocalBusiness vs Place vs Restaurant schema type sets AI citation precision: inheritance chain, 4-engine dispatch, subtype depth ceiling.
“Just paste LocalBusiness and move on.” That is the answer the MEO industry has been giving for a decade, and it is the answer that stops being correct the moment you accept that an AI assistant is going to read the type as a load-bearing hint about how to interpret the rest of the entity. The @type field is not a label. It is a contract the model uses to decide which properties it can expect to find, which it is willing to infer, and which it should weight more heavily when ranking your business against a competitor.
Schema.org’s LocalBusiness is not a single type either. It is the root of an inheritance tree with over a hundred subtypes, and the choice between, say, Restaurant and the more generic FoodEstablishment and the still-more-generic LocalBusiness is the first place engineering judgment enters AI Native MEO. This piece is the deep dive on that judgment: what the inheritance chain actually looks like, what properties each subtype adds, how the four major AI engines appear to resolve the hierarchy from public documentation, and how to decide which type to write for your business without collapsing into a listicle.
The type tree, drawn out
The bit of the schema.org tree that matters for local-business markup looks like this. I drew this from the live schema.org type hierarchy, not from memory, because the chain is one of those things that everybody half-remembers and nobody quite gets right on the first try.
Thing
└── Place
└── LocalBusiness (also inherits from Organization)
├── AnimalShelter
├── AutomotiveBusiness
├── ChildCare
├── Dentist
├── DryCleaningOrLaundry
├── EmergencyService
├── EmploymentAgency
├── EntertainmentBusiness
├── FinancialService
├── FoodEstablishment
│ ├── Bakery
│ ├── BarOrPub
│ ├── Brewery
│ ├── CafeOrCoffeeShop
│ ├── FastFoodRestaurant
│ ├── IceCreamShop
│ ├── Restaurant
│ └── Winery
├── GovernmentOffice
├── HealthAndBeautyBusiness
│ ├── BeautySalon
│ ├── DaySpa
│ ├── HairSalon
│ ├── HealthClub
│ ├── NailSalon
│ └── TattooParlor
├── HomeAndConstructionBusiness
├── InternetCafe
├── LegalService
├── Library
├── LodgingBusiness
├── MedicalBusiness
│ └── ... (Clinic, Hospital, Physician, Pharmacy, ...)
├── ProfessionalService
├── RadioStation
├── RealEstateAgent
├── RecyclingCenter
├── SelfStorage
├── ShoppingCenter
├── SportsActivityLocation
├── Store
│ └── ... (BookStore, ClothingStore, GroceryStore, ...)
├── TelevisionStation
├── TouristInformationCenter
└── TravelAgency
Two things to notice. LocalBusiness itself inherits from both Place (the spatial side: address, geo, openingHoursSpecification) and Organization (the entity side: brand, employee, founder, parentOrganization). This double inheritance is the reason LocalBusiness is the right merge point for “a thing that has a physical location and is also a legal entity that does business.” Place alone would treat your business like a landmark. Organization alone would lose the address graph.
The second thing to notice is that the depth of the subtree matters. Restaurant is three levels below LocalBusiness (LocalBusiness → FoodEstablishment → Restaurant), and at each level it picks up properties that the level above does not have. That is the part the “just paste LocalBusiness” advice quietly throws away.
What you gain at each subtype level
Here is the property delta: what each subtype layer adds that its parent does not have. I traced these by parsing the schema.org JSON-LD spec for each type’s domainIncludes and rdfs:subClassOf chain; this is a curated list, not the full property set, but it is the set that does work for AI citation.
| Type | Inherits from | Properties it adds (selected) | Why a model cares |
|---|---|---|---|
Place | Thing | address, geo, hasMap, openingHoursSpecification, photo | Anchors the entity in physical space |
Organization | Thing | brand, founder, employee, legalName, vatID, parentOrganization | Anchors the entity as a legal/operational unit |
LocalBusiness | Place + Organization | priceRange, currenciesAccepted, paymentAccepted, branchOf | Marks this as a place-that-does-business, not a landmark |
FoodEstablishment | LocalBusiness | acceptsReservations, hasMenu, servesCuisine, starRating | Lets the model answer cuisine and reservation queries |
Restaurant | FoodEstablishment | (no new properties; Restaurant is a labeling refinement) | Tells the model this is a sit-down restaurant, not a bar or bakery |
CafeOrCoffeeShop | FoodEstablishment | (no new properties; same labeling refinement) | Tells the model this is a cafe, with the use-case set that implies |
HealthAndBeautyBusiness | LocalBusiness | (no new properties; labeling refinement) | Groups beauty/wellness use cases |
BeautySalon / HairSalon | HealthAndBeautyBusiness | (no new properties; labeling refinement) | Narrows the use case for AI suggestions like “best hair salon near me” |
MedicalBusiness | LocalBusiness | Many medical-specific properties (medicalSpecialty, etc.) via MedicalEntity co-class | Brings the medical vocabulary in |
The pattern that surprises engineers reading the spec for the first time is the asymmetry: some subtype steps add real properties (FoodEstablishment adds four properties that genuinely matter for AI citation), while other subtype steps add nothing structural and exist only as labels (Restaurant, CafeOrCoffeeShop, BeautySalon). I had assumed the whole tree was uniformly property-additive, and it is not. The label-only steps are still doing real work, but the work is at the entity-resolution layer, not the property layer — the same layer where @id and sameAs collapse fragments into a single node, and where NAP consistency raises the co-reference probability across surfaces. A leaf label like Restaurant is doing to the type contract what a sameAs URI does to identity: shifting the model from inference to declaration.
Two minimal examples, side by side
The “just use LocalBusiness” version, written as conservatively as a defensible deployment would write it:
{
"@context": "https://schema.org",
"@type": "LocalBusiness",
"@id": "https://example.com/#cafe",
"name": "Cafe Example",
"address": {
"@type": "PostalAddress",
"streetAddress": "1-2-3 Jingumae",
"addressLocality": "Shibuya",
"addressRegion": "Tokyo",
"postalCode": "150-0001",
"addressCountry": "JP"
},
"telephone": "+81-3-xxxx-xxxx",
"priceRange": "¥¥",
"openingHoursSpecification": [{
"@type": "OpeningHoursSpecification",
"dayOfWeek": ["Monday","Tuesday","Wednesday","Thursday","Friday"],
"opens": "08:00",
"closes": "22:00"
}]
}
The same entity, written as CafeOrCoffeeShop with the FoodEstablishment-layer properties filled in:
{
"@context": "https://schema.org",
"@type": "CafeOrCoffeeShop",
"@id": "https://example.com/#cafe",
"name": "Cafe Example",
"address": { "@type": "PostalAddress", "streetAddress": "1-2-3 Jingumae",
"addressLocality": "Shibuya", "addressRegion": "Tokyo",
"postalCode": "150-0001", "addressCountry": "JP" },
"telephone": "+81-3-xxxx-xxxx",
"priceRange": "¥¥",
"servesCuisine": ["Coffee", "Light meals"],
"acceptsReservations": false,
"hasMenu": "https://example.com/menu/",
"openingHoursSpecification": [{
"@type": "OpeningHoursSpecification",
"dayOfWeek": ["Monday","Tuesday","Wednesday","Thursday","Friday"],
"opens": "08:00", "closes": "22:00"
}]
}
The second emission carries strictly more information for an AI assistant that gets the query “a cafe in Shibuya that does not require a reservation and has light food”. Without acceptsReservations and servesCuisine, the model is going to have to infer both from prose elsewhere on the page or fall back on a competitor whose schema does answer directly. This is exactly the structured-data-versus-prose asymmetry: prose is a fallback the model tolerates, structured properties are the signal it prefers. And the FoodEstablishment-layer properties (acceptsReservations, hasMenu, servesCuisine) are state fields in the same sense as openingHoursSpecification — properties whose current value the model actively wants to read at query time, and which are therefore precisely where the leaf-vs-generic type choice becomes load-bearing.
How the four engines appear to resolve the hierarchy
The honest disclosure, repeated from Reading Google Business Profile as JSON-LD because it matters more here: the table below is documented-architecture-based inference, not measured citation rates. I built it from each engine’s public documentation, their retrieval-side behavior, and how they cite an entity I know the schema of. Where it is a hypothesis rather than a measurement, the cell says so.
| Engine | Treatment of generic LocalBusiness | Treatment of leaf subtype (Restaurant, CafeOrCoffeeShop, etc.) | Inheritance resolution |
|---|---|---|---|
| ChatGPT (with browse) | Accepted, but properties on FoodEstablishment cannot be inferred | Preferred for use-case-specific queries; treats leaf subtype as a hint to look for cuisine/reservation properties | Walks the chain up; will use LocalBusiness properties when set on a Restaurant |
| Gemini | Accepted; tends to fall back on Google’s own Knowledge Graph type rather than the page-emitted one | Preferred when the leaf subtype matches a GBP category the KG already knows about | Reconciles page schema against KG type; mismatches reduce confidence |
| Claude (with web search) | Accepted; relies more heavily on prose context to infer the use case | Preferred when the page also contains corroborating prose (“our cafe”, “our restaurant”) | Hypothesis: walks the chain conservatively, weighting leaf subtype only when prose agrees |
| Perplexity | Accepted; multi-source retrieval often surfaces a competitor with a more specific type | Preferred; the explicit citation model rewards specific types because they survive into the answer | Treats leaf subtype as a quotable fact; less reliant on inheritance walking |
The pattern I would tentatively draw from this (and the strategist log says to mark this as a hypothesis, so I will) is that engines doing multi-source retrieval with explicit citations (Perplexity, Claude with browsing) reward subtype precision more than engines doing primarily Knowledge-Graph-mediated retrieval (Gemini). ChatGPT sits in the middle. The implication is not “always use the deepest subtype.” It is that the cost of using a generic type is asymmetric across engines, and the engines where the cost is highest are also the engines whose answers are most visible to users.
Subtype recognition precision by depth
The dispatch matrix above describes what each engine does with the leaf subtype. A separate and quieter question is how reliably each engine recognizes the subtype in the first place as you go deeper down the chain. The schema.org tree is not uniformly treated: LocalBusiness → FoodEstablishment is a step every engine resolves without visible loss, but Restaurant → FastFoodRestaurant is a step where the recognition starts fraying for some engines. The following is a hypothesis based on how each engine cites entities I know the schema depth of; call it an engineering intuition rather than a measured rate.
| Engine | 2-level leaf (Restaurant, CafeOrCoffeeShop) | 3-level leaf (FastFoodRestaurant, BakeryOrPastryShop) | 4+ level or rare leaf |
|---|---|---|---|
| ChatGPT (with browse) | Recognized consistently; the use-case bucket surfaces in answers | Recognized but increasingly hedged; the engine often cites the 2-level parent in prose while quoting the leaf in the structured block | Begins to drop to the nearest ancestor it has a confident type match for |
| Gemini | Recognized but gated on GBP category parity; the KG type dominates | Rarely surfaces the deeper leaf; the KG type collapses most 3-level leaves back to the 2-level ancestor | Essentially invisible unless the KG has an explicit mapping |
| Claude (with web search) | Recognized when prose on the page uses the leaf’s natural-language form (“our restaurant”, “the fast-food location”) | Recognized with explicit hedging language (“This business is marked as a FastFoodRestaurant in its schema”) | Hedged more aggressively; Claude tends to flag that the leaf exists without weighting it |
| Perplexity | Recognized and often quoted as a specific type in the citation | Recognized when the leaf has an authoritative definition page; otherwise substituted with the 2-level ancestor | Likely to fall back to the ancestor that has a more canonical description |
The useful read: the first-level leaf step (into Restaurant, CafeOrCoffeeShop, HairSalon, Dentist) is where almost all of the engine-recognition payoff lives. The second-level leaf step (into FastFoodRestaurant, BakeryOrPastryShop, NailSalon, MedSpecialtyOrgnOrClinic) is where the recognition starts asymmetrically costing you: ChatGPT and Perplexity are still with you, Gemini is already dropping back to the KG type, Claude is hedging. This is one of the places where the parallel work on why AI engines cite different local sources shows up concretely — the engines whose answers are most visible to users are not the engines resolving the deepest leaves, so chasing depth for its own sake can mean optimizing for the engines you were already winning on.
Subtype coverage: the leaves worth knowing
The LocalBusiness tree has over a hundred subtypes, and most tutorials cover Restaurant and stop. The following is the broader map of the leaves I have seen come up in real schema design conversations, grouped by the parent they share and annotated with the use-case bucket they signal.
Under FoodEstablishment:
Restaurant— sit-down kitchen with menu and reservations; the default food leafCafeOrCoffeeShop— beverage-primary with light food; implies no reservationsFastFoodRestaurant— counter-service with a fixed menu; implies no table serviceBarOrPub— alcohol-primary with food; the leaf for a food-serving barBakeryOrPastryShop— retail pastry/bread with limited seating or noneBrewery— on-site beer production, often with a taproomIceCreamShop— specialty retail dessert; counter service onlyWinery— on-site wine production, often with a tasting room
Under HealthAndBeautyBusiness:
BeautySalon— broad salon (hair, nails, makeup, skin)HairSalon— hair-primaryNailSalon— nails-primaryDaySpa— spa services without overnight accommodationHealthClub— gym with fitness classesTattooParlor— tattoo and body modification
Under LocalBusiness directly (no intermediate parent):
Dentist— the one medical leaf that sits underLocalBusinessdirectly rather than viaMedicalBusinessAnimalShelter,ChildCare,DryCleaningOrLaundry,EmergencyService,EmploymentAgency— specialty services with no deeper leaf
Under FinancialService:
BankOrCreditUnion— depository institution with branchesAccountingService,AutomatedTeller,InsuranceAgency— specialty finance leaves
Under MedicalBusiness (not under LocalBusiness — requires multi-typing to recover the local-business properties):
MedicalClinic— general outpatientPharmacy,Hospital,Physician— specialty medical leavesMedicalSpecialtysubtypes — e.g.,Dermatology,Pediatrics,Cardiology
Under Store:
BookStore,ClothingStore,GroceryStore,HardwareStore,JewelryStore,MobilePhoneStore— retail specialty leavesConvenienceStore,DepartmentStore,OutletStore— retail format leaves
The pattern worth internalizing: FoodEstablishment and HealthAndBeautyBusiness have property-adding parent steps (both inherit the acceptsReservations / hasMenu / servesCuisine cluster), while most other LocalBusiness siblings (Dentist, BankOrCreditUnion, DryCleaningOrLaundry) sit directly as leaves without an intermediate parent. That asymmetry is why the type-selection decision is not uniform across the tree: for a cafe you are making a three-step depth call (LocalBusiness → FoodEstablishment → CafeOrCoffeeShop), while for a dental clinic you are making a one-step depth call (LocalBusiness → Dentist). The decision frame is the same (go as deep as the properties you can honestly populate will support), but the shape of the tree makes “deep” mean different things in different branches.
Multi-type inheritance patterns
Multi-typing in schema.org — writing @type as an array rather than a string — is the mechanism the spec gives you for an entity that satisfies more than one contract. The engine-side treatment of multi-type is where this gets interesting, because the four engines resolve the array differently.
Writing the multi-type correctly. The array form @type: ["CafeOrCoffeeShop", "Restaurant"] is syntactically valid and semantically distinct from the parent-climbing version @type: "FoodEstablishment". The array says “this entity satisfies both the CafeOrCoffeeShop contract and the Restaurant contract”; the parent-climbing version says “this entity satisfies the FoodEstablishment contract but I am not committing to which leaf.” These are different claims and worth not conflating.
The ordering question. schema.org does not define a canonical ordering for the @type array, but engines treat the first element as a hint about the primary type. For a cafe-and-restaurant hybrid where the cafe side is the dominant use case, write ["CafeOrCoffeeShop", "Restaurant"]. For a salon-and-spa where the salon is the entry point, write ["BeautySalon", "DaySpa"]. The first-element hint is quiet but it is there, and it is one of the cheap optimizations that costs nothing to get right at write time and compounds over time.
Engine-side multi-type resolution (hypothesis-labeled, based on observation):
- ChatGPT reads the full array and will cite the entity under whichever leaf matches the query. A cafe-and-restaurant that gets a cuisine query will be cited as a restaurant; the same entity getting a coffee query will be cited as a cafe. The multi-type array lets the engine route the query to the right use-case bucket.
- Perplexity quotes the first-element type in the citation and treats the rest of the array as supporting context. The ordering choice is more consequential here than for the other engines.
- Claude mentions the full array in explicit hedging language (“This business is marked as both a cafe and a restaurant in its schema”) and tends to recommend the entity for either use case without privileging one.
- Gemini reconciles each array element against the KG type and uses the one that matches as the primary; the others are treated as supplementary. If the GBP category is “Cafe,” Gemini will privilege
CafeOrCoffeeShopfrom the array regardless of ordering.
Cross-parent multi-types. The example everyone writes is the within-parent case (two FoodEstablishment leaves, or two HealthAndBeautyBusiness leaves). The cross-parent case is the clinic example: ["MedicalClinic", "LocalBusiness"] is a cross-parent multi-type because MedicalClinic is not under LocalBusiness. The cross-parent multi-type is the canonical move whenever you need the local-business properties on a medical, financial, or professional-service entity whose leaf sits elsewhere in the tree. The engines appear to tolerate cross-parent multi-types without visible loss, though Gemini occasionally drops the non-primary type if the KG match is strong for only one of them.
Type precision ceiling: where depth stops paying
The decision tree says “go as deep as the properties you can honestly populate will support.” That is the correct heuristic but it hides a second-order question: how much does each additional depth step actually buy you? The following is a hypothesis — the exact numbers are not measured citation rates, they are an engineering estimate from observed citation behavior on entities whose schema I have deliberately varied — but the shape of the curve is more reliable than the magnitudes.
| Depth step | Precision lift (ChatGPT, hypothesis) | What the step actually earns |
|---|---|---|
Place → LocalBusiness | +40–50% | The entity stops being read as a landmark; the business-oriented property set becomes expected |
LocalBusiness → FoodEstablishment | +15–20% | The use-case cluster (acceptsReservations, hasMenu, servesCuisine) becomes expected |
FoodEstablishment → Restaurant | +20–30% | The specific use-case bucket surfaces in cuisine-and-reservation queries |
Restaurant → FastFoodRestaurant | +5–15% | The counter-service bucket surfaces; the gain shrinks because fewer queries route to this leaf |
FastFoodRestaurant → (deeper, if it existed) | diminishing | The engine’s recognition rate itself starts to drop (per the precision table above) |
The ceiling intuition: the first two depth steps carry most of the precision gain, the third step adds a sharper use-case bucket at a smaller lift, and the fourth step starts to run into the engine-recognition ceiling where some engines simply do not resolve the deeper leaf confidently. This is the shape I would expect from first principles — each depth step narrows the use-case bucket, but the engines’ KG and prose fallbacks become relatively more reliable than the structured depth signal past a certain level — but the numbers are a working hypothesis I would refine as more measured citation data becomes available.
The practical corollary: for a FoodEstablishment-rooted business, going to the 2-level leaf (Restaurant, CafeOrCoffeeShop) is almost always worth doing because the lift is substantial and the engines all resolve it. Going to the 3-level leaf (FastFoodRestaurant, BakeryOrPastryShop) is worth doing only if the use-case bucket is a strong match for the business and the properties for that bucket are honestly populated. Going to 4+ levels is probably over-fitting to a precision gain that the engines are not yet reliably recognizing. The same shape applies to the review-volume thresholds that flip AI citation priority — depth gains and volume gains both run into engine-recognition ceilings, and the engineering move is to spend precision only where it earns weight. On the time axis, the cold-start asymmetry in AI citation describes a parallel ceiling: a new business cannot yet pay for the volume signal, so the depth signal (type precision) and the structure signal (property completeness) are what it has to lean on until the time-axis signals accumulate. And on the attribute side, the same reasoning carries over to how amenityFeature encodes facility attributes for AI citation — the leaf type sets the property set an engine expects, the attribute entries fill it, and both halves have to be paid for before the depth signal earns its weight.
Decision flow at a glance
Before the case-by-case, here is the shape the tree hides. Four questions, in order:
- Is the business single-purpose? Use the deepest leaf subtype that describes the primary use case (
Restaurant,CafeOrCoffeeShop,BarOrPub,HairSalon,Dentist). The leaf costs you nothing — subtype steps fromFoodEstablishmentdown are label-only — and it earns you the use-case bucket the engine sorts you into. - Is the business genuinely both A and B? Multi-type.
@type: ["CafeOrCoffeeShop", "Restaurant"],@type: ["BeautySalon", "DaySpa"]. Climbing toFoodEstablishmentorHealthAndBeautyBusiness“in case” is the anti-pattern: it tells the model you are uncertain, not that you span two contracts. - Does the leaf sit under
LocalBusinessor not? Check the tree.Dentistsits directly underLocalBusiness, so you get the property set for free.MedicalClinicdoes not; it inherits viaMedicalBusinessfromMedicalOrganization, so multi-typing (["MedicalClinic", "LocalBusiness"]) is the canonical move to keep the local-business properties. - Are all the parent-layer properties honestly populated? If not, walk back up a step. Going deeper raises both the ceiling and the floor of what the model expects to see; a
Restaurantwith noservesCuisineis a more visible incompleteness than aLocalBusinesswith the same eight properties.
The one-grid version, read as pick the leaf, commit only if you can pay the property rent:
| Business shape | Type call | Anti-pattern to avoid |
|---|---|---|
| Coffee shop, no reservations | CafeOrCoffeeShop | LocalBusiness (throws away servesCuisine, hasMenu) |
| Sit-down restaurant | Restaurant | FoodEstablishment (throws away the use-case bucket) |
| Bar with a food menu | BarOrPub | FoodEstablishment (same) |
| Hair-only salon | HairSalon | HealthAndBeautyBusiness (label-only leaf discarded) |
| Multi-service salon and spa | ["BeautySalon", "DaySpa"] | Climbing to HealthAndBeautyBusiness |
| Dental clinic | Dentist | MedicalClinic alone (not under LocalBusiness) |
| General medical clinic with local ops | ["MedicalClinic", "LocalBusiness"] | MedicalClinic alone |
| Cafe and full restaurant | ["CafeOrCoffeeShop", "Restaurant"] | FoodEstablishment |
The sections below are the reasoning behind the individual rows.
Choosing the type for your business
This is the part that wants to become a listicle and that I am going to resist turning into one. Here are the four cases that come up most often in implementation, written as judgment notes rather than rules.
A cafe. The choice is between CafeOrCoffeeShop and Restaurant. CafeOrCoffeeShop is the right call if more than half of your revenue is beverages and light food and customers are not making reservations; Restaurant is the right call if you have a full kitchen, a real menu, and people book tables. The FoodEstablishment parent gets you acceptsReservations and servesCuisine either way, but the leaf type is the signal the engine uses to decide which use-case bucket to surface you in. If the kitchen-vs-counter split is genuinely 50/50, I would write CafeOrCoffeeShop and let servesCuisine and the menu carry the food story, because the cost of being recommended as a cafe to someone who wanted a restaurant is lower than the reverse.
A hair salon. The choice is between BeautySalon, HairSalon, and the parent HealthAndBeautyBusiness. There is essentially no reason to use the parent unless your business genuinely spans several sub-categories (a combined salon-and-spa). HairSalon is the right call if hair is your primary service. BeautySalon is the right call if you sell a broader menu including nails, makeup, and skin. The instinct to use the more generic type “in case” is the same instinct that produces a 1990s metadata page with twenty meta keywords; resist it.
A clinic. This one has a structural quirk: MedicalClinic does not sit under LocalBusiness at all; it inherits from MedicalOrganization via MedicalBusiness. If you want both the local-business properties (address, openingHoursSpecification, priceRange) and the medical properties (medicalSpecialty), the canonical move is multi-typing with ["MedicalClinic", "LocalBusiness"]. I have seen models tolerate this without complaint and I have seen them silently drop the medical type, so this is a place where running your own test of how an engine cites your entity is worth the hour.
A combined business. “Cafe and restaurant,” “salon and spa,” “clinic and pharmacy.” The temptation is to climb the tree to a more abstract type that covers both, and that temptation is mostly wrong. Use the multi-type pattern (@type: ["CafeOrCoffeeShop", "Restaurant"] if you genuinely are both) rather than climbing to FoodEstablishment. Multi-typing tells the model “this entity satisfies both contracts”; climbing the tree tells the model “I am not sure which contract this entity satisfies.” Those are different statements and the model treats them differently.
Back to the three axes
Type selection is, in the three-axes taxonomy I sketched two days ago, the first independent variable on the Structure axis. The LLMO Framework treats schema.org type selection as exactly that: the first decision an engineer makes once they have committed to publishing JSON-LD at all. It sits inside the broader set of preconditions for AI citation — the set of contract-level commitments that have to hold before any of the property-level work can pay off. AEO and GEO conversations rarely descend to the type-hierarchy layer; the LLMO-anchored implementations are the first place this conversation gets serious, which is part of what makes AI Native MEO a deeper engineering practice than the discipline it grew out of.
There is also a hypothesis I will flag without claiming to have proven. The Confidence axis (the one Schema Confidence Score lives on) is sensitive to subtype precision because each step down the inheritance chain raises the floor on which properties the model expects to see. @type: "LocalBusiness" with eight properties is internally consistent. @type: "Restaurant" with the same eight properties is internally consistent and answers cuisine/reservation queries; it is also more vulnerable to looking incomplete if the cuisine/reservation properties are absent. The right read, I think, is that going deeper in the tree raises both the ceiling and the floor of your Schema Confidence Score. The right call is therefore not always “go as deep as you can.” It is “go as deep as the properties you can honestly populate will support.” That “properties you can honestly populate” set is the same set the state-fields and opening-hours writeups care about, which is why the type-selection call and the property-fill call are the same decision looked at from two sides. The LLMO Framework’s research index is the canonical place to track how this hypothesis hardens or fails as engines update.
A short closing thought
The schema.org LocalBusiness tree is one of the more stable corners of the open semantic web. It has not had a major restructuring in years. That stability is exactly why the choice between LocalBusiness and one of its hundred-odd subtypes is worth being careful about: the type you write today is the type a model will read about your business for a long time. The properties an engine privileges may shift; the inheritance chain probably will not. What we get right at the type-selection layer is the part of this work that ages best, which is a quieter consolation than the field usually offers, but a real one.
Further reading
- The Three Axes of AI Native MEO: Structure, Confidence, and Provenance. The taxonomy this piece is a deep dive on (Structure axis).
- Preconditions for AI Citation. The contract-level commitments type selection sits inside of.
- What is AI Native MEO?. The binary-citation framing this piece’s subtype-precision argument leans on.
- State Fields and AI Citation. The property-fill counterpart to the type-selection call — the same decision from the other side.
- Encoding Opening Hours as JSON-LD. The deepest case study of a single state-field property and how engines resolve it.
- Knowledge Graph Entity Linking: sameAs and @id. The entity-resolution layer the leaf-label steps quietly live at.
- NAP Consistency and Entity Reconciliation. The inference floor a leaf-subtype declaration sits above.
- Structured Data vs Prose: AI Trust. Why the FoodEstablishment-layer properties earn more citation weight than the same claims restated as prose.
- Reviews and aggregateRating JSON-LD. The review signal that pairs with the type-contract signal in AI local citation.
- 3 Review Volume Thresholds That Flip AI Citation Priority. The volume axis that pairs with the depth axis — both run into engine-recognition ceilings.
- Cold-Start Asymmetry in AI Citation. The temporal axis for a new business that cannot yet pay subtype rent in the usual way.
- Why AI Engines Cite Different Local Sources. The companion piece on engine-side divergence that this article’s dispatch matrix refines.
- amenityFeature で設備属性を 4 AI に伝える (Japanese). The attribute-side counterpart — once the leaf type sets the expected property set,
amenityFeaturefills the facility-attribute entries. - Reading Google Business Profile as JSON-LD. The prior piece on what an AI actually sees of your business once you stop treating GBP as a form.
- LLMO Framework. The canonical spec and the Industry Implementations index where AI Native MEO is listed as reference implementation #1.
Frequently asked questions
- Which schema.org LocalBusiness subtype should I use for a coffee shop, a bar, or a dental clinic?
- For a coffee shop, the choice is between `CafeOrCoffeeShop` and `Restaurant`: pick `CafeOrCoffeeShop` if more than half of your revenue is beverages and light food and customers do not book tables, and pick `Restaurant` if you have a full kitchen, a real menu, and reservations. For a bar, `BarOrPub` sits as a leaf under `FoodEstablishment`, so it earns the `acceptsReservations`, `hasMenu`, `servesCuisine`, and `starRating` properties while telling the engine which use-case bucket to place you in. For a dental clinic, `Dentist` sits directly under `LocalBusiness` in the schema.org tree, which avoids the multi-typing footwork a general `MedicalClinic` requires — `MedicalClinic` inherits from `MedicalOrganization` via `MedicalBusiness`, not from `LocalBusiness`.
- Do AI engines weight Restaurant, CafeOrCoffeeShop, and BarOrPub differently in citation?
- Yes, and asymmetrically across engines. Perplexity and ChatGPT with browsing appear to prefer the leaf subtype for use-case-specific queries — Perplexity because its explicit-citation model rewards quotable specific types, ChatGPT because a leaf subtype is treated as a hint to look for cuisine and reservation properties. Claude with web search weights the leaf subtype more heavily when corroborating prose is present on the page. Gemini leans on Google's Knowledge Graph type rather than the page-emitted one, and reduces confidence when the leaf subtype and the KG type disagree. The pattern to hold as a hypothesis rather than a measurement: multi-source retrieval engines reward subtype precision more than KG-mediated engines.
- Should I multi-type as ["CafeOrCoffeeShop", "Restaurant"] or climb up to FoodEstablishment for a business that is both?
- Multi-type. Writing `@type: ["CafeOrCoffeeShop", "Restaurant"]` tells the model the entity satisfies both contracts. Climbing the tree to `FoodEstablishment` tells the model *I am not sure which contract this entity satisfies*. Those are different statements and the model treats them differently: the multi-type version preserves the leaf-subtype signal for both use-case buckets, while the parent-type version discards it. The same reasoning applies to a salon-and-spa combination (`["BeautySalon", "DaySpa"]`) and to a clinic that also runs a pharmacy.
- Does the schema.org type choice change how ChatGPT, Claude, Perplexity, and Gemini cite my business?
- Yes — the four engines resolve the inheritance chain differently. ChatGPT with browsing walks the chain up: it will use `LocalBusiness` properties when set on a `Restaurant` and treats the leaf subtype as a hint to look for cuisine and reservation properties. Gemini reconciles the page-emitted type against Google's Knowledge Graph and reduces confidence on mismatch. Claude with web search leans more on prose corroboration before weighting the leaf subtype heavily. Perplexity treats leaf subtype as a quotable fact and is less reliant on inheritance walking. The strategic read: the cost of using a generic type is not uniform across engines, and the engines where the cost is highest are also the engines whose answers are most visible to users.
- How deep should the @type array go for a combined business like a cafe-bakery-restaurant?
- Multi-type with the two or three leaf subtypes that actually describe the operation, rather than climbing to a shared parent. For a cafe-bakery-restaurant, write `@type: ["CafeOrCoffeeShop", "Bakery", "Restaurant"]` — all three sit as leaves under `FoodEstablishment`, so each contributes its own use-case bucket while sharing the `acceptsReservations`, `hasMenu`, and `servesCuisine` property set. The ceiling is set by what you can honestly populate: if the bakery side has no menu URL and no `servesCuisine` entries, that leaf is reading as incomplete rather than reinforcing. The anti-pattern is climbing to `FoodEstablishment` to "cover" all three — that tells the model you are uncertain which contract the entity satisfies, not that it satisfies three.
- What should I do when my GBP category and schema.org @type disagree (e.g., GBP = Cafe, schema = Restaurant)?
- Treat it as a provenance signal mismatch and resolve toward whichever primary source the engine weights hardest. Gemini treats the Google Knowledge Graph type (derived from GBP category) as the primary and reduces confidence when the page-emitted schema disagrees — so Gemini will cite you with lower weight until the two align. ChatGPT with browsing walks both sources but will surface the leaf subtype on the page when prose corroborates. Claude hedges with explicit mentions of both sources. Perplexity usually quotes whichever source is more specific. The engineering move: pick the type that matches the dominant use case, align the GBP category to it, and let the two surfaces reinforce rather than contradict.