How to optimize your restaurant for AI search in 2026
Your guests are asking an assistant instead of typing a query. This is the operator's side of that shift — how to publish menu data machines can parse, which crawlers to allow, and how to test whether ChatGPT and Gemini actually know your restaurant exists.
TL;DR — Key Takeaways
AI search optimization for restaurants — also called generative engine optimization (GEO) or answer engine optimization (AEO) — is the practice of publishing your own restaurant data in a form assistants can parse, verify and quote: structured menu markup, consistent business facts, and crawler permissions that let AI systems read the pages you want read.
Adoption is no longer theoretical. A Pew Research Center survey of 5,119 U.S. adults conducted 17–23 February 2026 found 49% now use AI chatbots, up from 33% in 2024; 44% use ChatGPT and 24% use Gemini. Google reported on its Q2 2026 earnings call that AI Mode passed 1 billion monthly active users and the Gemini app reached 950 million.
The difference from SEO is what gets returned. Search ranks a page; an assistant returns a claim. A PDF menu can rank in Google and still be uncitable, because there is no parseable statement of what you serve, at what price, with which allergens.
The highest-leverage single move is publishing your menu as `Menu`, `MenuSection` and `MenuItem` schema on an indexable HTML page, with identical name, address and phone everywhere else. Everything after that is amplification.
Intermenu exists to make that step trivial— a hosted, crawlable menu page per venue with structured dish, price, allergen and dietary fields in 15 languages, instead of a PDF behind a QR code.
This is the operator's side of the problem. If you want the diner's side — how tourists phrase the question and how citations get won in travel content — read our companion piece on getting cited by ChatGPT and Google AI Overviews when tourists ask where to eat.
Why diners now ask an AI assistant instead of searching
Because the question got more complicated than a search box handles well. "Gluten-free ramen near Kreuzberg, open after 22:00, takes walk-ins" is three filters and a constraint. A search engine returns ten links to sift; an assistant returns three names. Guests are choosing the shorter path.
That changes what a restaurant is competing for. In classic local SEO you fight for a position in a list. In an assistant answer there is no list — two or three restaurants and a sentence of justification each. Being fourth is the same as being invisible.
It also changes who loses. The venues that fall out first are not the ones with bad food; they are the ones whose facts live where a machine cannot read them. A menu locked in a PDF, hours that disagree between your site and Google, a cuisine described as "modern European" with no dish names — legible to a human, opaque to a retrieval system. The2026 discovery process for tourists now routes through at least one machine before it reaches a person.
How ChatGPT, Gemini and Perplexity decide which restaurants to recommend
There are three retrieval paths, and most answers blend them: the model's training data, a live web search against an index, and grounded structured data from a partner source such as Google's local business index or a maps provider. Restaurants get cited when the same facts appear consistently across all three.
What that means concretely:
Training data rewards being written about. If food blogs, city guides and local press named your restaurant alongside specific dishes before the model's cut-off, the model has a prior about you.
Live retrieval rewards being crawlable and current. ChatGPT search, Gemini grounding and Perplexity fetch pages at query time. If your menu is a PDF or a JavaScript widget with no server-rendered text, there is nothing to fetch.
Grounded local data rewards your Google Business Profile. Google's AI surfaces lean on its own local index, which is why GBP hygiene has an outsized effect on Gemini answers specifically.
Be honest about the limits. None of these systems publish a ranking specification, all of them change monthly, and there is no Search Console for LLMs — no impressions, no citation counts, no dashboard. Anyone selling a guaranteed "AI ranking" is selling a story. What you control is whether your data is machine-readable, consistent and current, and that is a durable bet regardless of which assistant wins.
The 8 signals that get a restaurant cited by AI
There is no published ranking factor list, but there is a consistent pattern in what gets quoted and what does not. Eight signals do most of the work, and seven of them are entirely under your control.
NAP consistency— name, address and phone identical, character for character, across your website, Google Business Profile, Apple Business Connect, TripAdvisor, delivery platforms and social bios. Conflicting facts make a model hedge, and a hedging model recommends someone else.
Structured menu data— dishes, sections, prices, allergens and diets as machine-readable fields, not an image or PDF. This is the single biggest gap in the industry.
Review volume, recency and reply rate— recent reviews with owner replies signal an operating, attended business. Ten reviews from 2023 signal a question mark.
Third-party mentions— being named in city guides, food blogs and local press, ideally alongside a dish. "Known for their sourdough-crust marinara" is quotable; "great Italian" is not.
Category accuracy— a precise primary category ("Neapolitan pizza restaurant") rather than a vague one. Category is a hard filter in local retrieval, not a soft signal.
Photos— recent, plentiful images on GBP and your site. They feed the visual answer surface and the freshness read.
Hours accuracy— including holiday and special hours. "Open now" is among the most common local prompts, and a wrong closing time filters you out of the answer entirely.
Multilingual availability— an assistant answering in Spanish prefers a source it can quote in Spanish. A multilingual menu multiplies the queries you are eligible for.
How to structure your menu data so AI can read it
A PDF menu is a picture of a menu. Even when the text layer is extractable, there is no statement that "Margherita" is a `MenuItem` in the `MenuSection` "Pizza" costing €12.50 and containing gluten and dairy. Publishing the same content as an HTML page with `Menu` schema turns your menu from a document into a queryable dataset.
The schema.org types that matter, in order:
`Menu`— the menu itself, linked from your `Restaurant` entity via `hasMenu`.
`MenuSection`— Starters, Pizza, Desserts. Sections give the model the vocabulary it needs to answer "do they have a vegetarian starter?"
`MenuItem`— the dish, with `name`, `description`, `offers.price`, `offers.priceCurrency`, `suitableForDiet` and `menuAddOn`.
`RestrictedDiet`— the controlled vocabulary behind `suitableForDiet`: `GlutenFreeDiet`, `VeganDiet`, `VegetarianDiet`, `HalalDiet`, `KosherDiet`, `LowLactoseDiet` and others. Use the schema values, not free text like "GF-friendly".
A minimal, correct menu block:
{
"@context": "https://schema.org",
"@type": "Menu",
"name": "Dinner",
"inLanguage": "en",
"hasMenuSection": [{
"@type": "MenuSection",
"name": "Pizza",
"hasMenuItem": [{
"@type": "MenuItem",
"name": "Margherita",
"description": "San Marzano tomato, fior di latte, basil, 24-hour dough",
"suitableForDiet": "https://schema.org/VegetarianDiet",
"offers": { "@type": "Offer", "price": "12.50", "priceCurrency": "EUR" }
}]
}]
}
Two details separate menus that get quoted from menus that get skipped. Allergens and diets belong in fields, not in the description sentence — a model can filter on `suitableForDiet` and can only guess at "contains nuts, probably". And each language needs its own crawlable URL with `inLanguage` set, or an assistant answering in French has nothing French to cite.
This is the layer Intermenu handles: a real HTML page per venue and per language, with dish, section, price and allergen and dietary tags stored as structured fields rather than typography. If you are still on a PDF, our walkthrough on creating a digital menu is the shortest route out.
Google Business Profile as your AI source of truth
Treat your Google Business Profile as the canonical record every other system reconciles against. Gemini and Google's AI surfaces query Google's local index directly, and third-party assistants routinely land on the same facts through search results. If GBP and your website disagree, GBP usually wins — so make it right first. Multi-site operators have the extra job of keeping NAP consistent across locations.
The fields that carry the most weight for machine answers:
Primary category— the most specific accurate option. Add secondary categories for real capabilities only.
Menu link— point it at your live structured menu page, not a PDF and not a delivery aggregator. An Intermenu menu URL works here because it is a real page rather than a file download.
Attributes— outdoor seating, wheelchair access, reservations, dietary options. These map almost one-to-one onto the filters in constraint-heavy prompts.
Hours and special hours— maintained through holidays. The most common cause of a restaurant being silently excluded from an answer.
Description— dense with cuisine specifics, signature dishes and neighbourhood, written as factual sentences rather than marketing adjectives.
Photos— refreshed regularly, matching the dish names on your menu.
The field-by-field version is in our Google Business Profile guide for restaurants; the map-pack mechanics sit in restaurant Google Maps SEO.
Why AI assistants read your review replies
Because replies are indexed, timestamped text that you wrote about your own business — and unlike your website copy, they sit next to independent evidence. A model summarising "what are people saying" reads the reviews and the responses together, which makes your reply the one piece of that page you fully control.
Three practical consequences:
Reply rate reads as an operating signal. Recent owner responses make a profile look attended; an unanswered wall of reviews looks dormant, and dormancy is a reason not to recommend.
Replies are where you correct the record."We installed a dedicated gluten-free fryer in March" published as a reply becomes a retrievable, dated fact. The same sentence on an About page rarely does.
Tone gets summarised. Defensive replies get characterised as defensive; specific, factual ones get characterised as responsive — and that characterisation is what ends up in the answer.
Our templates for responding to negative restaurant reviews cover the wording. The point here is that you are writing for two audiences now.
Structured data that actually matters for restaurants
Five types carry the load: `Restaurant`, `Menu`, `FAQPage`, `LocalBusiness` and `AggregateRating`. Implement them as JSON-LD in the page head. Google's local business structured data guidance is the reference for the property names, and `Restaurant` is a subtype of `LocalBusiness`, so one block covers both.
The core entity block, with the menu linked rather than inlined:
{
"@context": "https://schema.org",
"@type": "Restaurant",
"name": "Trattoria Nove",
"servesCuisine": "Neapolitan",
"priceRange": "20-35 EUR",
"telephone": "+39 06 1234 5678",
"address": {
"@type": "PostalAddress",
"streetAddress": "Via Nove 12",
"addressLocality": "Roma",
"postalCode": "00184",
"addressCountry": "IT"
},
"openingHours": "Tu-Su 12:00-15:00,19:00-23:00",
"acceptsReservations": "True",
"hasMenu": "https://trattorianove.example/en/menu",
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.6",
"reviewCount": "412"
}
}
And an FAQ block for the questions guests actually ask before booking:
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [{
"@type": "Question",
"name": "Do you have gluten-free pizza?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Yes. Every pizza is available on a certified gluten-free base, prepared in a separate area with dedicated utensils."
}
}]
}
Two honest caveats. `AggregateRating` must reflect ratings you genuinely collect and display — inventing it is a policy violation. And Google restricted FAQ rich results years ago, so do not expect an accordion in the SERP. The markup still earns its place: it hands an assistant a clean question-and-answer pair in exactly the shape an answer wants.
What to put in robots.txt and llms.txt
`robots.txt` is where you tell AI crawlers whether they may read you. For a restaurant the answer is almost always yes — you are trying to be found, not protecting a paywalled archive. The mistake to avoid is a blanket block inherited from a website template.
The user agents worth naming explicitly:
GPTBot— OpenAI's crawler for training data. Documented in OpenAI's bots reference.
OAI-SearchBot— OpenAI's crawler for ChatGPT search results. Blocking this one removes you from ChatGPT's search surface; blocking GPTBot does not.
ChatGPT-User— fetches a page when a user or an action triggers a live visit.
Google-Extended— a control token for Gemini and Vertex AI grounding, listed in Google's crawler documentation. Disallowing it does not affect Google Search indexing, but it does opt you out of the AI grounding you are trying to win.
ClaudeBot, plus `Claude-User` and `Claude-SearchBot` — Anthropic's crawlers, described in Anthropic's crawler support article.
PerplexityBot and Perplexity-User— indexing and user-triggered fetching, per Perplexity's bot documentation.
CCBot—Common Crawl, the open corpus that feeds a long tail of models and tools.
A permissive baseline for a restaurant site:
User-agent: GPTBot
Allow: /
User-agent: OAI-SearchBot
Allow: /
User-agent: Google-Extended
Allow: /
User-agent: ClaudeBot
Allow: /
User-agent: PerplexityBot
Allow: /
User-agent: CCBot
Allow: /
Sitemap: https://example.com/sitemap.xml
`llms.txt` is a newer and much softer idea: a markdown file at your root giving a model a curated map of your site, proposed at llmstxt.org. Be clear-eyed — it is a community convention, not a standard, and no major provider has committed to honouring it. It costs an hour and cannot hurt.
For a restaurant a useful `llms.txt` is short: one line on what you are and where, links to the menu page for each language, hours and location, allergen policy, reservation link, and a last-updated timestamp. We publish our own at intermenu.io/llms.txt as a working shape to copy.
How to test whether AI knows your restaurant
Run the same prompts across ChatGPT, Gemini and Perplexity once a month and write down what comes back. It is not a measurement system — there is no impression data — but it is a reliable smoke test, and the failure modes it exposes are specific enough to fix.
Ten prompts to paste as-is, substituting your details:
"What is [restaurant name] in [city]?"
"What kind of food does [restaurant name] serve, and what is it known for?"
"Does [restaurant name] have vegan options?"
"Is [restaurant name] open on Sunday evening?"
"How much does dinner cost at [restaurant name]?"
"Best [your cuisine] restaurant in [neighbourhood]"
"Where can I eat [your signature dish] in [city]?"
"Gluten-free [your cuisine] near [landmark closest to you]"
"I have a nut allergy — which restaurants near [landmark] can accommodate me?"
"Compare [your restaurant] and [your closest competitor]."
A good answer: your name appears, the cuisine is precise, at least one real dish is named, the price band is roughly right, hours match reality, and dietary claims match what you offer. A bad answer: the assistant has never heard of you, confuses you with a similarly named venue, names dishes you removed two years ago, says it cannot confirm your hours, or recommends three competitors and not you for prompts 6 to 9.
Map each failure to a cause. No knowledge at all is a crawlability or mentions problem. Wrong dishes is a stale-menu problem — a one-field edit on an Intermenu menu, a print cycle on a PDF. Hedging on hours is a GBP problem. Losing prompts 6 to 9 while winning 1 to 5 means you are known but not associated with the attributes people search on: a category, description and dish-naming problem.
What to fix first: a 30-day plan
Sequence matters, because the later steps only pay off once your facts are stable. Four weeks, roughly a day of work each week.
Week 1 — make the facts agree. Audit NAP across your site, GBP, Apple Business Connect, TripAdvisor, delivery platforms and social bios. Fix hours, add special hours, set the most specific primary category. Run the ten test prompts and save the answers as your baseline.
Week 2 — publish the menu as data. Move off PDF to a crawlable menu page per language —Intermenu publishes one per venue per locale — with dish names, prices, allergens and diets in structured fields. Point your GBP menu link at it and add `Restaurant` and `Menu` JSON-LD.
Week 3 — open the doors and answer the questions. Review `robots.txt` for the crawler list above, publish an `llms.txt`, and add an FAQ page with `FAQPage` markup covering the ten questions guests ask before booking. Reply to every review from the last 90 days.
Week 4 — build outside evidence. Pitch two local food writers or city-guide editors with a specific angle and a named dish. Refresh photos. Re-run the ten prompts and compare with your baseline.
Expect the second month to look flat. Crawl cycles, index refreshes and model updates all lag, and improvements show up in live-retrieval answers first and in training-data answers much later. What compounds is the underlying asset: a restaurant whose menu, hours, categories and dietary data are correct and machine-readable is easier for every system to recommend, including the ones that do not exist yet. That is the case for treating this as part of your restaurant technology stack rather than a campaign.
Publish a machine-readable menu free with Intermenu →
Frequently asked questions
How do I get my restaurant to show up in ChatGPT?
Make your facts machine-readable and consistent: structured menu data on a crawlable page, identical NAP everywhere, an accurate Google Business Profile, `OAI-SearchBot` and `GPTBot` allowed in robots.txt, and mentions in local publications. Then test monthly with named prompts.
What is the best platform to optimize a restaurant's presence for AI search?
There is no single platform that covers everything. You need a structured menu source, a maintained Google Business Profile, and a review workflow. Intermenu handles the menu layer — crawlable, multilingual pages with dish, price, allergen and dietary fields as structured data.
Is AI search optimization the same as SEO?
They overlap but optimize for different outputs. SEO aims at ranking a page; AI search aims at supplying a citable fact. Structured data, crawlability and consistency serve both, which is why doing this work rarely costs you anything in traditional search.
Should I block AI crawlers in robots.txt?
Almost never, if discovery is your goal. Blocking `Google-Extended` opts you out of Gemini grounding without protecting anything; blocking `OAI-SearchBot` removes you from ChatGPT search. Publishers with paid archives have a real trade-off here. Restaurants generally do not.
Does llms.txt actually work?
It is unproven. `llms.txt` is a community proposal, not an adopted standard, and no major AI provider has publicly committed to reading it. It takes an hour, costs nothing and may help. Treat structured data and crawlability as the real work.
Can I track AI search traffic?
Only partially. There is no Search Console equivalent for LLMs. You can see referrals from ChatGPT, Perplexity and Copilot in your analytics referrer data, and you can log AI user agents in your server logs — but most assistant answers produce no click at all, so referrals undercount your actual visibility.
Does a PDF menu work for AI search?
Poorly. Even when the text is extractable, there is no structure telling a model which line is a dish, which number is a price, or which item is vegan. An HTML menu with `Menu` and `MenuItem` markup answers all three questions unambiguously.
How long does it take to see results?
Live-retrieval answers can change within days of a crawl. Training-data answers change on model release cycles, which is months. Plan on a quarter before the picture shifts meaningfully, and re-run your test prompts monthly so you can see which of the two is moving.
Do multilingual menus help AI visibility?
Yes, measurably in eligibility terms. An assistant answering in Italian prefers a source it can quote in Italian. Publishing each language at its own crawlable URL with `inLanguage` set makes you a candidate for a much larger set of prompts.
Do reviews matter more than my website for AI answers?
For "is it good" questions, usually yes — third-party evidence outranks self-description. For what you serve, when you open and what it costs, your own structured data is the source. You need both, and they must not contradict each other.