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.

TypeInherits fromProperties it adds (selected)Why a model cares
PlaceThingaddress, geo, hasMap, openingHoursSpecification, photoAnchors the entity in physical space
OrganizationThingbrand, founder, employee, legalName, vatID, parentOrganizationAnchors the entity as a legal/operational unit
LocalBusinessPlace + OrganizationpriceRange, currenciesAccepted, paymentAccepted, branchOfMarks this as a place-that-does-business, not a landmark
FoodEstablishmentLocalBusinessacceptsReservations, hasMenu, servesCuisine, starRatingLets the model answer cuisine and reservation queries
RestaurantFoodEstablishment(no new properties; Restaurant is a labeling refinement)Tells the model this is a sit-down restaurant, not a bar or bakery
CafeOrCoffeeShopFoodEstablishment(no new properties; same labeling refinement)Tells the model this is a cafe, with the use-case set that implies
HealthAndBeautyBusinessLocalBusiness(no new properties; labeling refinement)Groups beauty/wellness use cases
BeautySalon / HairSalonHealthAndBeautyBusiness(no new properties; labeling refinement)Narrows the use case for AI suggestions like “best hair salon near me”
MedicalBusinessLocalBusinessMany medical-specific properties (medicalSpecialty, etc.) via MedicalEntity co-classBrings 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.

EngineTreatment of generic LocalBusinessTreatment of leaf subtype (Restaurant, CafeOrCoffeeShop, etc.)Inheritance resolution
ChatGPT (with browse)Accepted, but properties on FoodEstablishment cannot be inferredPreferred for use-case-specific queries; treats leaf subtype as a hint to look for cuisine/reservation propertiesWalks the chain up; will use LocalBusiness properties when set on a Restaurant
GeminiAccepted; tends to fall back on Google’s own Knowledge Graph type rather than the page-emitted onePreferred when the leaf subtype matches a GBP category the KG already knows aboutReconciles page schema against KG type; mismatches reduce confidence
Claude (with web search)Accepted; relies more heavily on prose context to infer the use casePreferred when the page also contains corroborating prose (“our cafe”, “our restaurant”)Hypothesis: walks the chain conservatively, weighting leaf subtype only when prose agrees
PerplexityAccepted; multi-source retrieval often surfaces a competitor with a more specific typePreferred; the explicit citation model rewards specific types because they survive into the answerTreats 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.

Engine2-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 answersRecognized but increasingly hedged; the engine often cites the 2-level parent in prose while quoting the leaf in the structured blockBegins to drop to the nearest ancestor it has a confident type match for
GeminiRecognized but gated on GBP category parity; the KG type dominatesRarely surfaces the deeper leaf; the KG type collapses most 3-level leaves back to the 2-level ancestorEssentially 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
PerplexityRecognized and often quoted as a specific type in the citationRecognized when the leaf has an authoritative definition page; otherwise substituted with the 2-level ancestorLikely 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:

Under HealthAndBeautyBusiness:

Under LocalBusiness directly (no intermediate parent):

Under FinancialService:

Under MedicalBusiness (not under LocalBusiness — requires multi-typing to recover the local-business properties):

Under Store:

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):

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 stepPrecision 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)diminishingThe 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:

  1. 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 from FoodEstablishment down are label-only — and it earns you the use-case bucket the engine sorts you into.
  2. Is the business genuinely both A and B? Multi-type. @type: ["CafeOrCoffeeShop", "Restaurant"], @type: ["BeautySalon", "DaySpa"]. Climbing to FoodEstablishment or HealthAndBeautyBusiness “in case” is the anti-pattern: it tells the model you are uncertain, not that you span two contracts.
  3. Does the leaf sit under LocalBusiness or not? Check the tree. Dentist sits directly under LocalBusiness, so you get the property set for free. MedicalClinic does not; it inherits via MedicalBusiness from MedicalOrganization, so multi-typing (["MedicalClinic", "LocalBusiness"]) is the canonical move to keep the local-business properties.
  4. 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 Restaurant with no servesCuisine is a more visible incompleteness than a LocalBusiness with the same eight properties.

The one-grid version, read as pick the leaf, commit only if you can pay the property rent:

Business shapeType callAnti-pattern to avoid
Coffee shop, no reservationsCafeOrCoffeeShopLocalBusiness (throws away servesCuisine, hasMenu)
Sit-down restaurantRestaurantFoodEstablishment (throws away the use-case bucket)
Bar with a food menuBarOrPubFoodEstablishment (same)
Hair-only salonHairSalonHealthAndBeautyBusiness (label-only leaf discarded)
Multi-service salon and spa["BeautySalon", "DaySpa"]Climbing to HealthAndBeautyBusiness
Dental clinicDentistMedicalClinic 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

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.