What Is Restaurant Schema Markup and Why It Matters for Your WordPress Food Ordering Site
When someone searches “best margherita pizza near me,” Google doesn’t just show ten blue links anymore. It pulls star ratings, price ranges, cuisine types, and even individual menu items directly into the search results. That extra visual information — called rich snippets — comes from structured data you embed in your website’s code, and it can dramatically change whether someone clicks your listing or your competitor’s.
Schema markup is a standardized vocabulary (maintained at Schema.org) that tells search engines exactly what your content represents. Instead of Google guessing that “$14.99” on your page is a menu item price, schema explicitly labels it as the price of a specific dish, tied to a specific restaurant, with a specific cuisine type and customer rating.
The impact is measurable. Search results with rich snippets consistently earn higher click-through rates than plain listings. A study by Milestone Research analyzing over 4.5 million search queries found that structured data can increase organic click-through rates by up to 30%. For restaurants competing in local search — where the top three results capture the vast majority of clicks — that difference translates directly into orders.
This guide focuses specifically on on-page schema for your menu items and menu pages — the structured data that lives on your WordPress site and describes your dishes, prices, reviews, and cuisine. This is distinct from your <a href="https://www.wpslash.com/how-to-optimize-your-restaurant-website-for-local-seo-with-wordpress-google-business-profile-schema-markup-and-location-based-keywords-to-rank-1-in-near-me-searches-complete-guide/" title="How to Optimize Your Restaurant Website for Local SEO with WordPress: Google Business Profile, Schema Markup, and Location-Based Keywords to Rank #1 in 'Near Me' Searches (Complete Guide)”>Google Business Profile optimization, which handles location-based signals like your address, hours, and map placement. Both matter, but on-page menu schema is where most restaurant websites leave significant SEO value on the table.
Types of Restaurant Schema You Should Implement
Schema.org defines a hierarchy of types specifically designed for restaurants and food service businesses. Understanding how they nest together is essential before you start writing any code or configuring any plugin.
The Core Schema Types
- Restaurant — The top-level entity. Describes your business with properties like name, address, cuisine, telephone, and opening hours. This is a subtype of FoodEstablishment.
- Menu — Represents your entire menu. A Restaurant can have one or more Menu objects (lunch menu, dinner menu, drinks menu).
- MenuSection — Groups related items within a menu (Appetizers, Entrees, Desserts, Beverages). Each Menu contains one or more MenuSections.
- MenuItem — An individual dish or drink. This is where you define the name, description, price, image, and dietary information for each offering.
- Offer — Attached to a MenuItem to specify pricing, currency, and availability. This is especially useful for specials and time-limited deals.
- AggregateRating — Summarizes customer ratings (e.g., 4.6 out of 5 based on 238 reviews). Can be applied to the Restaurant or individual MenuItems.
- Review — Individual customer reviews with author, rating, and review body. Google has strict policies here — only genuine reviews are permitted.
- NutritionInformation — Calorie counts, fat content, protein, and other nutritional data for a MenuItem. Increasingly valuable as health-conscious diners search for this information.
How They Nest Together
Think of it as a tree structure: Restaurant → Menu → MenuSection → MenuItem → Offer + NutritionInformation. The Restaurant entity sits at the root. Inside it, the hasMenu property points to your Menu. The Menu uses hasMenuSection to organize items into categories. Each MenuSection uses hasMenuItem to list individual dishes. And each MenuItem can include an offers property for pricing and a nutrition property for dietary data.
[IMAGE: Visual hierarchy diagram showing the nesting structure of Restaurant schema types, from Restaurant at the top flowing down through Menu, MenuSection, MenuItem, and branching to Offer, NutritionInformation, and Review]
Required vs. Recommended Properties
Google requires a minimum set of properties for rich results eligibility. For a Restaurant, the name, address, and image properties are essential. For MenuItem, you need at least name and offers (with price and priceCurrency). The description, image, and nutrition properties are recommended — they won’t prevent your schema from validating, but including them significantly increases your chances of earning rich snippets.
How to Add Menu Schema Markup to WooCommerce Product Pages Using JSON-LD
If you’re running your restaurant menu through WooCommerce — which is the approach used by FoodMaster (WooFood) to power online ordering — each menu item is already a WooCommerce product. This gives you a huge advantage: you can dynamically pull product data into your schema markup instead of hardcoding everything.
A Complete JSON-LD Example for a Single Menu Item
Here’s what a fully structured JSON-LD block looks like for a single pizza product page:
{
"@context": "https://schema.org",
"@type": "MenuItem",
"name": "Margherita Pizza",
"description": "Wood-fired pizza with San Marzano tomato sauce, fresh mozzarella, basil, and extra virgin olive oil.",
"image": "https://yoursite.com/wp-content/uploads/margherita-pizza.jpg",
"offers": {
"@type": "Offer",
"price": "14.99",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock"
},
"nutrition": {
"@type": "NutritionInformation",
"calories": "266 calories",
"fatContent": "10 g",
"proteinContent": "12 g"
},
"suitableForDiet": "https://schema.org/VegetarianDiet",
"menuAddOn": {
"@type": "MenuItem",
"name": "Extra Toppings",
"offers": {
"@type": "Offer",
"price": "2.00",
"priceCurrency": "USD"
}
}
}
Dynamically Generating Schema from WooCommerce Product Data
Hardcoding JSON-LD for every menu item isn’t practical when you have 30 or more dishes. Instead, add this to your child theme’s functions.php file to automatically generate MenuItem schema from your WooCommerce product data:
add_action('wp_head', 'restaurant_menu_item_schema');
function restaurant_menu_item_schema() {
if (!is_product()) return;
global $product;
$product = wc_get_product(get_the_ID());
if (!$product) return;
$image = wp_get_attachment_url($product->get_image_id());
$rating_count = $product->get_rating_count();
$schema = array(
'@context' => 'https://schema.org',
'@type' => 'MenuItem',
'name' => $product->get_name(),
'description' => wp_strip_all_tags($product->get_short_description()),
'image' => $image ? $image : '',
'offers' => array(
'@type' => 'Offer',
'price' => $product->get_price(),
'priceCurrency' => get_woocommerce_currency(),
'availability' => $product->is_in_stock()
? 'https://schema.org/InStock'
: 'https://schema.org/OutOfStock'
)
);
if ($rating_count > 0) {
$schema['aggregateRating'] = array(
'@type' => 'AggregateRating',
'ratingValue' => $product->get_average_rating(),
'reviewCount' => $rating_count
);
}
echo ''
. wp_json_encode($schema, JSON_UNESCAPED_SLASHES)
. '';
}This function fires on every WooCommerce product page, pulls the product title, description, price, currency, stock status, featured image, and average rating, then outputs clean JSON-LD in the page head. If you’re using FoodMaster’s WooCommerce-based restaurant ordering system, your menu items are already WooCommerce products, so this code works out of the box with your existing setup.
Adding Restaurant-Level Schema to Your Menu Page
For your main menu page (the page that lists all your dishes), you’ll want a Restaurant schema that references the full menu structure. Create a separate function that targets your menu page by ID or slug, and nest your MenuSections and MenuItems within the Restaurant entity using the hierarchy described earlier.
Using WordPress Plugins to Automate Restaurant Schema Without Writing Code
Not everyone wants to edit PHP files, and that’s perfectly reasonable. Several WordPress plugins can handle schema markup through visual interfaces. Here’s how the main options compare for restaurant-specific schema.
Rank Math
Rank Math is the most flexible option for restaurants. Its Schema Templates feature (available in the Pro version) lets you create custom schema types and apply them automatically to specific post types or categories. You can build a MenuItem schema template, map its fields to WooCommerce product data, and have it applied to every product in your “Menu” category automatically. Rank Math also supports the Restaurant schema type natively in its local SEO module.
Yoast SEO
Yoast handles basic LocalBusiness and Restaurant schema through its settings panel, and it automatically generates Product schema for WooCommerce items. However, Yoast doesn’t natively support MenuItem, Menu, or MenuSection schema types. You’ll get generic Product markup on your menu items rather than food-specific structured data. For many restaurants, this is still better than nothing — Product schema with price and reviews does generate rich snippets — but it’s not semantically ideal.
Schema Pro
Schema Pro stands out for its repeater fields and custom schema type support. You can build MenuItem schema from scratch, create field mappings to pull data from custom fields or WooCommerce product fields, and apply the schema conditionally. It’s the best plugin option if you want full MenuItem schema without touching code, though the learning curve is steeper than Rank Math’s interface.
[IMAGE: Screenshot comparison showing the schema configuration interfaces of Rank Math Schema Templates and Schema Pro custom schema builder for a restaurant menu item]
Key Limitation Across All Plugins
No mainstream SEO plugin natively supports the full Menu → MenuSection → MenuItem hierarchy out of the box. They all handle Restaurant and Product well, but the food-specific schema types require either custom configuration within the plugin or manual JSON-LD additions. If you’re running a plugin like Rank Math alongside a WooCommerce restaurant plugin, the best approach is often to let Rank Math handle the Restaurant-level schema and use custom JSON-LD (via the code method above) for individual MenuItem markup on product pages.
Testing and Validating Your Restaurant Schema
Adding schema markup without validating it is like cooking without tasting. Errors in your structured data can prevent rich snippets from appearing — or worse, trigger a manual action from Google.
Step 1: Google Rich Results Test
Visit Google’s Rich Results Test and enter your menu page URL. This tool shows you exactly which rich result types your page is eligible for and flags any errors or warnings. Green checkmarks mean your schema is valid and eligible. Yellow warnings indicate recommended properties you’re missing. Red errors mean required fields are absent and the schema won’t generate rich snippets.
Step 2: Schema Markup Validator
The Schema.org Validator checks your markup against the full Schema.org specification, not just Google’s subset. This is useful for catching structural issues like incorrect nesting — for example, placing a MenuItem directly inside a Restaurant without the intermediate Menu and MenuSection layers.
Common Errors Restaurant Owners Encounter
- Missing
imageon MenuItem — Google strongly recommends images for food items. Without them, your chances of earning rich snippets drop significantly. - Incorrect price format — The
priceproperty must be a number (e.g., “14.99”), not a formatted string (e.g., “$14.99”). The currency goes inpriceCurrency. - MenuSection placed outside Menu — MenuSections must be nested within a Menu using
hasMenuSection. Placing them at the top level breaks the hierarchy. - Self-served review markup — Google’s guidelines explicitly prohibit marking up reviews you wrote yourself or fabricated. Only genuine customer reviews qualify. Violating this policy can result in a manual action that removes all rich snippets from your site — not just the offending pages.
- Duplicate schema conflicts — If your SEO plugin outputs Product schema and your custom code outputs MenuItem schema for the same page, Google may get confused. Choose one approach per page and disable the other.
Advanced Schema Strategies: Connecting Menu Schema to Your Ordering System, Adding Offers for Specials, and Monitoring Performance
Once your basic menu schema is in place and validated, these advanced techniques help you squeeze more value from structured data.
Time-Limited Offer Schema for Daily Specials
If you run lunch specials, happy hour deals, or seasonal menu items, the Offer schema type supports validFrom and validThrough date properties. This tells Google the deal is temporary, which can trigger special display treatments in search results:
"offers": {
"@type": "Offer",
"price": "8.99",
"priceCurrency": "USD",
"validFrom": "2025-01-06T11:00:00-05:00",
"validThrough": "2025-01-06T14:00:00-05:00",
"availability": "https://schema.org/InStock"
}If you’re managing specials through WooCommerce sale prices — which FoodMaster supports natively — you can modify the dynamic schema function to detect when a product has a sale price and automatically include the sale date range in the Offer markup.
Building a Complete Browsable Menu in Search
Google has experimented with displaying full restaurant menus directly in search results. To be eligible, your schema needs the complete Restaurant → hasMenu → Menu → hasMenuSection → MenuSection → hasMenuItem → MenuItem chain on a single page. This is most practical on your main menu page rather than individual product pages. Structure your JSON-LD to include every section and item, even if the block is large — Google can parse substantial JSON-LD without issues.
Connecting Schema to WooCommerce Availability
The dynamic code example earlier already maps is_in_stock() to the schema availability property. This means when you mark a menu item as out of stock in WooCommerce (perhaps you’ve run out of a seasonal ingredient), the schema automatically updates to OutOfStock. This keeps your structured data accurate and prevents the frustrating experience of a customer clicking through from search only to find an unavailable item.
Monitoring Performance in Google Search Console
After implementing schema, track its impact in Google Search Console. Navigate to the Enhancements section in the left sidebar — you’ll see reports for each rich result type Google has detected on your site (Product, Review snippet, etc.). These reports show valid items, items with warnings, and errors.
For measuring the actual CTR impact, go to Performance → Search Results and compare your click-through rate for menu-related queries before and after implementing schema. Filter by page to isolate your menu pages specifically. Give it at least four to six weeks — Google needs time to recrawl your pages and start displaying the enhanced results.
A practical benchmarking approach: record your average CTR for your top 20 menu-related queries before adding schema. Revisit those same queries six weeks later. Restaurant sites that implement comprehensive menu schema typically see CTR improvements ranging from 15% to 35% on those specific queries, depending on how competitive the local search landscape is.
Putting It All Together
Restaurant schema markup isn’t a one-time task — it’s an ongoing part of your site’s SEO maintenance. Every time you add a new dish, update a price, or launch a seasonal special, your structured data should reflect those changes. If you’re using WooCommerce with dynamic schema generation, most updates happen automatically. Pair that with a complete restaurant ordering plugin that keeps your product data clean and organized, and you’ve built a system where your menu pages consistently earn the rich snippets that drive more clicks, more orders, and more revenue from organic search.