ION Hospitality

· Uncategorized

Restaurant Menu Schema: Use a Menu URL, Plus Copy‑Paste JSON‑LD

Implementation-first guide for restaurants. Publish a stable menu URL first, add copy‑paste JSON‑LD examples, test with Rich Results and Search Console,...

The fastest correct fix is to add a visible menu page to your site, then point to it with the menu (or hasMenu) property inside your Restaurant or LocalBusiness structured data. Test that page with the Rich Results Test or Search Console’s URL inspection tool before you touch anything else. Item-level JSON-LD with MenuItem and MenuSection is a nice upgrade for richer semantics, but it’s optional. Nail the menu URL first.

TL;DR:

  • Using a stable, visible menu page URL is the most reliable method to link your menu to Google and should be prioritized over complex nested schema.
  • Implementing schema with menu or hasMenu properties is sufficient for most restaurants; item-level markup benefits only if your menu is stable and automatically synchronized.
  • Ensure your schema properties, such as priceCurrency, offers, and name, are correctly formatted and match visible content to avoid common validation errors.
  • Google’s structured data policies require visible, truthful menu content; misleading or hidden data can lead to ineligible markup and potential policy violations.
  • Regular testing with Google’s Rich Results Test and Search Console is essential to maintain eligibility, especially after menu updates or changes in menu structure.

Table of Contents

What Is Menu Schema Markup and Which Schema.org Types Matter

Menu schema markup is the structured data that tells Google what’s actually on your menu, not just that you have one. Schema defines three connected types: Menu, MenuSection, and MenuItem. Think of them as nested boxes.

A Menu is the top-level container. It links down to one or more MenuSection entries (Appetizers, Entrees, Desserts) through hasMenuSection. Each MenuSection links down to individual MenuItem entries through hasMenuItem. That’s the whole hierarchy: Menu → MenuSection → MenuItem.

Your Restaurant or LocalBusiness entity connects to all of this with either menu or hasMenu. Both accept a URL, plain text, or a full nested Menu object, according to the Google-flavored Schema.org definition. That flexibility matters when you’re deciding how deep to go.

If you run multiple menus, use separate Menu objects (or separate pages) for each:

  • Dine-in menu — your primary, most detailed menu
  • Takeout or delivery menu — often a subset with different pricing
  • Seasonal or limited-time menu — swapped in and out, so it needs the shortest update cycle

For most restaurant sites, a stable menu URL beats a sprawling nested JSON-LD block. Full nesting earns its complexity only when your menu rarely changes or your CMS can auto-generate the markup from the same data feeding your visible page.

What Google Actually Recommends for Menu Markup

Google’s own guidance is blunt: for LocalBusiness and Restaurant types, provide the menu as a URL using the menu property in line with trends in gastronomy, and let that page carry your dish names, descriptions, and prices. That’s the primary Google-supported method for connecting search engines to your menu content, and it’s the one that scales without constant maintenance headaches.

Google’s structured data policies attach real constraints to this, though:

  • Marked-up content must be visible to users on the page. No hiding dish names or prices in code that never renders on screen.
  • Structured data can’t be used to mislead or deceive. Listing a “vegan” dish that isn’t, or a $12 price that’s actually $18, is a spam policy violation, not a shortcut.
  • Missing required properties can make your entire markup ineligible for rich results, not just the item with the problem.

Here’s the catch nobody likes hearing: implementing everything correctly still doesn’t guarantee Google will display a rich result for your listing. Structured data is a signal Google uses when it chooses to, not a switch you flip. Google’s own supported structured data list confirms eligibility and display are two different things. Treat schema as one lever in a broader SEO push, not a magic trigger for menu-item search snippets.

The Property Checklist You Need Before You Ship

Two separate checklists apply here: one for your business entity, one for the menu content itself.

For Restaurant or LocalBusiness:

  • name — your restaurant’s actual name, matching what’s on the page
  • url — your website’s canonical address
  • telephone — where applicable, formatted consistently across your site
  • openingHoursSpecification — structured hours, not a plain-text sentence
  • menu or hasMenu — pointing to a live URL or a nested Menu object

For Menu, MenuSection, and MenuItem, if you go granular:

  • name and description for each item
  • offers with price and priceCurrency (more on formatting below)
  • inLanguage when you run multilingual menus
  • suitableForDiet for vegan, gluten-free, or other diet-specific tags
  • nutrition when you actually publish nutritional data
  • image for dishes where a photo helps conversion, not just SEO

A few formatting details trip up more webmasters than the actual schema logic does. Use ISO 4217 currency codes like USD, and keep price as a plain numeric string with no dollar sign attached, per Schema.org’s MenuItem guidance. Keep your JSON-LD text synchronized word-for-word with what’s visible on the page. And format any dates or timestamps, like special-menu availability windows, in ISO 8601.

Copy-Paste JSON-LD Examples for Restaurant Menus

Nested menu schema data structure illustration

Here’s the minimal version first, the one Google actually recommends. This sits inside your Restaurant markup and points straight to your menu page:

{
  "@context": "https://schema.org",
  "@type": "Restaurant",
  "name": "Example Kitchen",
  "url": "https://www.examplekitchen.com",
  "telephone": "+1-555-123-4567",
  "menu": "https://www.examplekitchen.com/menu",
  "openingHoursSpecification": {
    "@type": "OpeningHoursSpecification",
    "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
    "opens": "11:00",
    "closes": "22:00"
  }
}

For a granular version, you nest the full hierarchy. This is heavier to maintain, so reserve it for menus that don’t change weekly:

{
  "@context": "https://schema.org",
  "@type": "Menu",
  "name": "Dinner Menu",
  "hasMenuSection": {
    "@type": "MenuSection",
    "name": "Entrees",
    "hasMenuItem": {
      "@type": "MenuItem",
      "name": "Grilled Salmon",
      "description": "Wild-caught salmon with roasted vegetables",
      "suitableForDiet": "https://schema.org/GlutenFreeDiet",
      "offers": {
        "@type": "Offer",
        "price": "24.00",
        "priceCurrency": "USD"
      }
    }
  }
}
What to ChangeWhy It Matters
url and menu valuesMust point to your live, indexable pages
name fieldsMatch exactly what’s printed on the visible menu
priceCurrencyUse the ISO code for your actual market, not a symbol
image URLsShould resolve to real, crawlable photos, not placeholders
Language tags via inLanguageAdd one Menu object per language if you run bilingual menus

Pro Tip:If you manage seasonal menus, duplicate the Menu object rather than editing the live one in place. Swap the @id and dates, then republish. It keeps your Rich Results Test history clean and avoids accidentally breaking a menu that’s still technically active.

How to Implement Menu Schema Step by Step

  1. Lock down your visible menu content first. Build a stable page (or a stable page fragment) with real dish names, descriptions, and prices. Structured data describes what’s on the page. It doesn’t create content that isn’t there.
  2. Choose shallow or granular. A URL-only menu property covers most restaurant sites. Full MenuItem nesting is worth the extra work only if you want dish-level rich results or you’re feeding this from a database that already tracks price and diet tags.
  3. Add the JSON-LD to the page. Place it in the <head> or right near the menu content in the HTML. Keep it byte-for-byte consistent with what a diner actually sees on screen.
  4. Test before you publish anything permanent. Run the page through the Rich Results Test, fix any errors, then use Search Console’s URL inspection tool to request indexing.
  5. Monitor and update. Menus change. Check Search Console’s enhancement reports periodically, and update the JSON-LD the same day you update the printed menu, not weeks later.

Pro Tip:Set a calendar reminder tied to your seasonal menu rotation. Schema markup that quietly falls out of sync with your actual menu is one of the most common structured data failures, and it’s entirely avoidable with a five-minute check.

Testing and Monitoring Your Menu Markup

Three tools cover nearly every validation need here, and none of them cost anything.

The Rich Results Test checks whether your markup qualifies for a specific rich result type and flags syntax errors immediately. Schema.org’s own Menu type page is worth bookmarking as a reference for correct nesting when you’re building granular examples from scratch. And Search Console’s URL inspection tool tells you whether Google has actually indexed the page and whether it recognizes the enhancement at all, which is a different question from whether the syntax is valid.

Run this checklist on every menu page you mark up:

  • Does the JSON-LD match the visible page word-for-word?
  • Are all required properties present for the type you’re using?
  • Fix hard errors first. Warnings are second priority. Google often still processes markup with warnings.
  • Check Search Console’s enhancement reports monthly for coverage drops, not just at launch.

A page that passes the Rich Results Test today can still lose eligibility later if you edit the visible menu and forget the JSON-LD. Recheck after every significant content update.

Common Menu Schema Mistakes and Quick Fixes

Most menu schema problems trace back to one of five habits.

  • Hidden JSON-LD. If your markup lists a dish, description, or price that isn’t visible on the page, that’s a direct violation of Google’s structured data policies. Fix it by making the JSON-LD a mirror of the page, not an enhancement of it.
  • AJAX and single-page app loading issues. If your menu loads dynamically after the initial page render, crawlers may see an empty shell. Server-side render the menu, or expose a stable, static URL that Google can fetch directly.
  • Currency and price formatting errors. A price field with a dollar sign, or a missing priceCurrency, causes parsing failures more often than any other single mistake.
  • Bad availability windows on offers. If you attach time-limited pricing, use valid ISO 8601 date and time formats, not free text like “weekends only.”
  • Inventing properties. Stick to documented Schema.org properties and values. A custom field that looks plausible still won’t be recognized, and it clutters your markup for no benefit.

When to Handle Menu Schema Yourself vs. Bring in Help

A menu URL through Restaurant markup is genuinely something most webmasters can implement in an afternoon; it doesn’t demand ongoing engineering support once it’s live. Where it gets harder is granular, item-level markup that has to stay synchronized with a CMS, a POS-driven pricing feed, or a seasonal rotation schedule. That’s where DIY implementations quietly rot: someone updates the printed menu, nobody touches the JSON-LD, and three months later the markup is describing dishes that don’t exist anymore.

Agencies that specialize in restaurant SEO tend to build the synchronization into the CMS itself, so menu updates and schema updates happen in one motion, then confirm the result in Search Console instead of hoping it worked. The approach leans on that same discipline: pairing the technical deployment with the actual content, photography, and copy that make the menu worth marking up in the first place.

Get Your Menu Schema Built Right the First Time

This service is an alternative to a slow DIY schema project for restaurant owners who’d rather have it done correctly once than debug JSON-LD between shifts. The team builds the menu page, the structured data, and the ongoing monitoring as one connected job instead of three separate headaches, and there’s no commission taken on the sales or bookings that follow.

Ionhospitality

The Website Development service covers the technical side directly: JSON-LD deployment, server-side rendering for menus that need it, Rich Results testing before launch, and Search Console setup so you can see what’s working. Pair that with Content Creation for the menu copy and photography that actually make a schema-marked-up dish worth clicking on. If your menu changes seasonally, monthly monitoring catches the drift before Google does. Get a quote from Ionhospitality and find out what a properly synced menu page could do for your search visibility.

Sources

FAQ

What Is an Example of Menu Schema Markup?

The simplest example is a Restaurant type with a menu property pointing to a URL, like "menu": "https://example.com/menu". A more detailed example nests a Menu object with MenuSection and MenuItem entries, each carrying an offers block for price, as shown in Schema.org’s own examples.

Do I Need Item-Level Schema, or Is a Menu URL Enough?

A menu URL through the menu or hasMenu property is the Google-recommended approach and is enough for most restaurant sites. Item-level MenuItem markup adds value mainly when your menu is stable and your data can stay automatically synced.

Is FAQ Schema Still Relevant Alongside Menu Schema?

FAQ schema still works on pages where it fits the content, but Google has scaled back how often it shows FAQ rich results in search. It’s separate from menu schema and doesn’t affect your menu’s eligibility either way.

What Are the 7 Parts of a Menu?

Menu design conventions vary, but a typical restaurant menu breaks into sections like appetizers, soups and salads, entrees, sides, desserts, beverages, and specials. In schema terms, each of these maps naturally to its own MenuSection under a parent Menu object.

Why Isn’t My Correctly Marked-Up Menu Showing a Rich Result?

Valid markup makes you eligible, but Google decides case by case whether to display a rich result, and correct implementation never guarantees display. Check Search Console’s enhancement reports to confirm Google recognized the markup, then treat schema as one part of a broader SEO effort rather than a standalone fix.

Want this done for you?

Book a free discovery call

Tell us about your restaurant and what you want more of — guests, private events, a stronger brand — and we’ll walk you through how we’d get you there.

Book a Discovery Call