Why Wilmington restaurants disappear in Google and Perplexity results (and the fix)

A Wilmington restaurant owner Googled her own business name in March 2025 and found something strange. Her restaurant appeared in the old-style search results (ten blue links), but when Google showed its new AI Overview (the AI-generated summary box at the top of results), her restaurant disappeared. A tourist searching "restaurants in Wilmington VT" saw an AI Overview listing four restaurants. Hers was not one of them. She had 43 Google reviews (4.6 stars), a website with menu and hours, and she had been in business for 11 years. But Google's AI could not figure out what type of business she was, so it skipped her.

The problem was not her content or her reviews or her reputation. The problem was structured data. Her website had no machine-readable markup telling Google "this is a restaurant, here is the cuisine type, here is the address, here are the hours, here is the menu." Google's AI could see the website (a human could read it fine), but the AI could not extract structured facts from plain paragraphs of text. A competitor the AI did cite had schema markup on their site (invisible code that labels everything for machines). Google's AI read that markup, extracted the facts instantly, and cited the competitor. The Wilmington restaurant without markup was invisible to AI even though a human could see all the same information on their homepage.

This is happening to restaurants all along the Route 9 corridor (Wilmington, West Dover, Marlboro, Brattleboro) and across Windham County. As Google, ChatGPT, and Perplexity shift from ranking links to generating answers, structured data is becoming the difference between being cited and being invisible. If your restaurant website does not have schema markup (the technical term for this machine-readable code), you are losing customers to competitors who do have it, even if your food is better and your reviews are stronger.

This post explains what structured data is, why Google and AI tools require it to cite restaurants, what specific markup Wilmington and Route 9 corridor restaurants need, and how to add it to your site (or check whether you already have it). This is not optional nice-to-have SEO. This is the infrastructure that makes your restaurant discoverable when someone 50 miles away asks Google or ChatGPT where to eat in Wilmington.

Why AI Overviews and ChatGPT can't cite restaurants without structured data

Google's new AI Overviews (the summary boxes that appear above traditional search results) and ChatGPT recommendations are not based on ranking links anymore. They are based on extracting facts from websites and synthesizing them into answers. When someone searches "Italian restaurants in Wilmington VT" or asks ChatGPT "where should I eat in Wilmington Vermont," the AI needs to identify which businesses are restaurants, what cuisine they serve, where they are located, what their hours are, and whether they have relevant attributes (outdoor seating, reservations, dietary options).

If your website has structured data markup (schema.org code), the AI reads it instantly. The markup says "this business is a Restaurant, cuisine is Italian, address is 123 Main Street Wilmington VT, phone is (802) 464-xxxx, hours are Monday-Saturday 5-9pm, priceRange is $$, serves vegetarian and gluten-free, reservations recommended." The AI extracts all of this in milliseconds and decides whether to cite you based on how well you match the query.

If your website has no structured data, the AI has to guess. It reads your homepage paragraphs, tries to figure out what type of business you are, tries to extract hours from a sentence like "We're open most evenings for dinner, give us a call," tries to figure out pricing from menu items or vague phrases like "affordable family dining." AI is bad at guessing. It gets things wrong or it gives up and skips you entirely. A human reading your site can figure it out. An AI reading unstructured text often cannot.

Here is the brutal reality: two restaurants with identical content (same cuisine, same hours, same menu, same reviews) will get wildly different AI visibility depending on whether they have structured data. The restaurant with schema markup gets cited. The restaurant without it disappears.

A Wilmington breakfast spot tested this in early 2025. Their website had a clear homepage ("Breakfast and lunch cafe in downtown Wilmington, open 7 AM to 2 PM daily, serving omelets, pancakes, sandwiches, and fresh-baked pastries"). A human could read that and know exactly what the business was. But when the owner searched "breakfast Wilmington VT," Google's AI Overview listed three breakfast spots. Hers was not one of them. She checked the three competitors Google cited. All three had schema markup (she used a schema checker tool to verify). She hired a developer to add Restaurant schema to her site (type: Restaurant, servesCuisine: Breakfast, address, phone, hours, priceRange, menu). Two weeks later, she tested the same search. Now her cafe was cited in the AI Overview. The schema made her visible.

What schema markup actually is (and why it's invisible to humans)

Schema markup is code you add to your website's HTML that labels every piece of information for machines. It is invisible to human visitors (it does not change how your site looks), but it is highly visible to Google, ChatGPT, Perplexity, and other AI tools.

Here is an example. Your homepage might say:

"We're located at 25 Route 9 West in Wilmington, Vermont. Open Tuesday through Saturday, 5 PM to 9 PM. Call us at (802) 464-1234 for reservations."

A human reads that and understands: address is 25 Route 9 West, town is Wilmington, state is Vermont, hours are Tuesday-Saturday 5-9pm, phone is (802) 464-1234, reservations are available.

An AI reading plain text has to parse that sentence, figure out which part is the address, which part is the phone number, which part is the hours, and guess whether "call for reservations" means reservations are required or optional. It is hard for AI to do this reliably across thousands of websites with different writing styles.

With schema markup, you label every piece of information explicitly:

"address": {
  "@type": "PostalAddress",
  "streetAddress": "25 Route 9 West",
  "addressLocality": "Wilmington",
  "addressRegion": "VT",
  "postalCode": "05363"
},
"telephone": "+1-802-464-1234",
"openingHours": "Tu-Sa 17:00-21:00"

Now the AI knows exactly what each piece of information is. No guessing. No parsing sentences. The facts are labeled and structured. AI extracts them instantly and uses them to decide whether your restaurant matches the user's query.

Schema markup is written in a format called JSON-LD (a structured data language). It sits in your website's code (usually in the <head> section or at the bottom of the page). Visitors never see it. Google, ChatGPT, and other AI tools read it every time they crawl your site.

Most Wilmington restaurant websites have zero schema markup. A few have basic LocalBusiness schema (which is better than nothing but not specific enough for restaurants). Very few have full Restaurant schema with all the relevant properties (cuisine, menu, dietary options, reservations policy, price range). The restaurants with full schema dominate AI Overviews and ChatGPT recommendations. The restaurants without it are invisible.

The six pieces of schema markup every Wilmington restaurant needs

If you run a restaurant anywhere in Wilmington, West Dover, or along the Route 9 corridor, your website needs these six schema properties at minimum to be discoverable in AI search:

1. Business type: Restaurant (not just LocalBusiness)

Schema has a hierarchy of business types. "LocalBusiness" is a generic type. "Restaurant" is a specific subtype. Google and AI tools treat Restaurant schema differently from generic LocalBusiness schema. Restaurant schema unlocks special features (menu display in search results, cuisine filtering, dietary options, reservations links).

Your schema must declare "@type": "Restaurant" explicitly. If your schema says "@type": "LocalBusiness" (which many site builders default to), Google does not know you are a restaurant. It knows you are some kind of local business, but it does not know what kind. AI tools skip you when users search for restaurants because you are not tagged as one.

2. Cuisine type (servesCuisine property)

The servesCuisine property tells Google and AI what kind of food you serve. Examples: "American", "Italian", "Mexican", "French", "Asian Fusion", "Pizza", "Breakfast", "Seafood", "Barbecue", "Farm-to-table".

This property is critical for cuisine-specific queries. When someone searches "Italian restaurant Wilmington VT" or asks ChatGPT "where can I get pizza near Wilmington Vermont," AI filters by the servesCuisine property. If your schema does not list a cuisine type, AI does not know whether you match the query. You are invisible.

You can list multiple cuisines if relevant. Example: "servesCuisine": ["American", "Farm-to-table", "Seafood"]. Be accurate. Do not list "Italian" if you serve American food with one pasta dish on the menu. AI cross-checks your schema against your menu and reviews. Mismatched schema hurts your credibility.

3. Full address (PostalAddress schema with street, city, state, zip)

Your schema must include a complete structured address:

"address": {
  "@type": "PostalAddress",
  "streetAddress": "25 Route 9 West",
  "addressLocality": "Wilmington",
  "addressRegion": "VT",
  "postalCode": "05363",
  "addressCountry": "US"
}

This tells Google and AI exactly where you are located. It also helps with proximity queries ("restaurants near me," "restaurants in Wilmington," "restaurants on Route 9"). If your schema has no address or an incomplete address (missing zip code or state), AI cannot reliably determine your location and may skip you for location-based queries.

4. Phone number (in international format)

Include your phone number in schema using international format: "telephone": "+1-802-464-1234". The +1 is the US country code. The format tells AI this is a phone number (not some other string of digits).

Phone numbers in schema unlock click-to-call features in mobile search results and make it easy for AI to cite your contact info when users ask "what's the phone number for [restaurant name]?"

5. Opening hours (openingHours or openingHoursSpecification)

List your hours in structured format:

"openingHours": [
  "Mo-Th 17:00-21:00",
  "Fr-Sa 17:00-22:00",
  "Su 16:00-21:00"
]

Or if your hours are complex (different hours for lunch vs. dinner, seasonal variations), use openingHoursSpecification:

"openingHoursSpecification": [
  {
    "@type": "OpeningHoursSpecification",
    "dayOfWeek": ["Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
    "opens": "17:00",
    "closes": "21:00"
  }
]

Structured hours allow Google to show "Open now" or "Closes soon" labels in search results. They allow AI to answer queries like "what restaurants in Wilmington are open on Monday" or "where can I get breakfast in Wilmington Vermont" (AI filters by hours and cuisine to find breakfast spots open in the morning).

If your schema has no hours or vague hours, AI cannot determine when you are open and may skip you for time-sensitive queries.

6. Price range (priceRange property)

The priceRange property uses dollar signs to indicate relative cost: "$" (inexpensive, most entrees under $15), "$$" (moderate, entrees $15-30), "$$$" (upscale, entrees $30-50), "$$$$" (fine dining, entrees $50+).

Example: "priceRange": "$$"

This property helps AI match your restaurant to budget-conscious queries ("cheap restaurants in Wilmington VT," "affordable dinner Wilmington") or upscale queries ("nice restaurants in Wilmington Vermont," "fine dining Wilmington"). If you have no priceRange in your schema, AI cannot filter by budget and you miss queries from users with specific price expectations.

A Wilmington Italian restaurant added these six schema properties in late 2024. Before: their website had LocalBusiness schema (type: LocalBusiness, name, address, phone). That was it. No cuisine, no hours, no price range. When tourists searched "Italian restaurant Wilmington VT," the restaurant did not appear in Google's AI Overview. ChatGPT did not cite them when asked "where should I get Italian food in Wilmington Vermont." After: they upgraded their schema to Restaurant type, added servesCuisine: "Italian", added full address, phone, structured hours (Tuesday-Saturday 5-9pm), and priceRange: "$$". They also added menu schema (see next section). Two weeks later, they tested the same searches. Google's AI Overview now listed them as one of four Italian restaurants in the area. ChatGPT cited them in three out of four queries. The six schema properties transformed their AI visibility.

Why menu schema is the difference between being cited and being skipped

Beyond the six core properties, the single most valuable schema property for restaurants is menu schema (hasMenu property with Menu and MenuItem objects). Menu schema tells Google and AI exactly what dishes you serve, what they cost, and whether you have specific dietary options (vegetarian, vegan, gluten-free).

Here is why menu schema matters: when someone asks ChatGPT "where can I get gluten-free pasta in Wilmington Vermont" or searches Google for "restaurants with vegetarian options Wilmington VT," AI looks for menu schema with suitableForDiet properties or menuItem descriptions that mention dietary options. If your menu schema lists a gluten-free pasta dish or marks items as vegetarian, AI can cite you confidently. If your website has a menu page but no menu schema, AI has to read plain text menu items and guess whether you have gluten-free options. AI is bad at guessing and often skips ambiguous cases.

Menu schema also helps with dish-specific queries. If someone searches "best burger Wilmington VT" or asks ChatGPT "where can I get a good steak near Wilmington," AI reads menu schema to see which restaurants serve burgers or steak. Restaurants with structured menu data get cited. Restaurants with text-only menus do not.

Here is a simplified example of menu schema:

"hasMenu": {
  "@type": "Menu",
  "hasMenuSection": [
    {
      "@type": "MenuSection",
      "name": "Entrees",
      "hasMenuItem": [
        {
          "@type": "MenuItem",
          "name": "Grass-fed Burger",
          "description": "8oz Vermont grass-fed beef, lettuce, tomato, brioche bun, served with fries",
          "offers": {
            "@type": "Offer",
            "price": "16.00",
            "priceCurrency": "USD"
          },
          "suitableForDiet": "http://schema.org/GlutenFreeDiet"
        },
        {
          "@type": "MenuItem",
          "name": "Vegetable Stir-Fry",
          "description": "Seasonal vegetables, ginger-soy sauce, jasmine rice",
          "offers": {
            "@type": "Offer",
            "price": "18.00",
            "priceCurrency": "USD"
          },
          "suitableForDiet": ["http://schema.org/VegetarianDiet", "http://schema.org/VeganDiet"]
        }
      ]
    }
  ]
}

This markup tells AI: you serve a burger ($16), you serve a vegetarian/vegan stir-fry ($18), and you have gluten-free options. AI can now cite you for "burger Wilmington VT," "vegetarian restaurants Wilmington VT," "vegan options Wilmington," and "gluten-free dining Wilmington VT."

Adding menu schema is tedious (you have to mark up every dish), but it is incredibly powerful for AI visibility. Many restaurants skip it because it takes time. The restaurants that do it dominate dietary-specific and dish-specific queries.

A Wilmington cafe had a breakfast and lunch menu on their website (omelets, pancakes, sandwiches, salads). The menu was plain HTML text, no schema. When tourists searched "gluten-free breakfast Wilmington VT," the cafe did not appear in results even though they had gluten-free pancakes and bread. A competitor with menu schema (marking gluten-free items explicitly) was cited instead. The cafe added menu schema for 18 of their most popular items, marking gluten-free and vegetarian options. They tested searches two weeks later. Now they appeared in Google AI Overviews for "gluten-free breakfast Wilmington VT" and ChatGPT cited them when asked "where can I get a vegetarian breakfast in Wilmington Vermont." Menu schema unlocked a whole category of dietary-specific queries they had been invisible for.

How to check whether your restaurant already has schema markup

Before you add schema, check whether your site already has it. Many modern website platforms (Squarespace, Wix, WordPress with certain themes or plugins) add basic LocalBusiness schema automatically. You may have some schema already, but it may not be complete or specific enough for restaurants.

Here is how to check:

Step one: Use Google's Rich Results Test

Go to https://search.google.com/test/rich-results and enter your restaurant's homepage URL. Google will analyze the page and show you what structured data it finds. If it finds Restaurant schema, it will display the properties (name, address, phone, cuisine, hours, etc.). If it finds only LocalBusiness schema (or no schema at all), you will see that too.

Step two: View your page source

Visit your restaurant's homepage, right-click, and choose "View Page Source." Search (Ctrl+F or Cmd+F) for "@type": "Restaurant" or "schema.org". If you find JSON-LD schema blocks, read through them to see what properties are included. Look for the six core properties (type: Restaurant, servesCuisine, address, phone, hours, priceRange) and check whether you have menu schema (hasMenu).

Step three: Use a schema markup validator

Use a tool like Schema Markup Validator (validator.schema.org) or the Structured Data Linter (linter.structured-data.org). Paste your homepage URL or paste your schema code directly. These tools will validate the schema and flag any errors or missing properties.

If your site has no schema, you need to add it. If your site has LocalBusiness schema but not Restaurant schema, you need to upgrade it. If your site has Restaurant schema but is missing key properties (cuisine, hours, menu), you need to complete it.

A Wilmington barbecue restaurant checked their schema using Google's Rich Results Test in early 2025. The test showed LocalBusiness schema with name, address, and phone. No type: Restaurant. No cuisine. No hours. No menu. The restaurant was being indexed as a generic local business, not as a restaurant. Google and AI had no idea they served barbecue or what their hours were. The owner hired a developer to upgrade the schema to Restaurant type and add servesCuisine: "Barbecue", hours, priceRange: "$$", and basic menu schema for their most popular items (pulled pork, brisket, ribs, with prices). They re-tested two weeks later. Google's Rich Results Test now showed full Restaurant schema with all properties. Their AI visibility improved immediately (they started appearing in "barbecue Wilmington VT" searches and ChatGPT started citing them for barbecue queries).

How to add schema markup if you have a custom-coded site

If your restaurant website is custom-coded (HTML, CSS, JavaScript, PHP), you or your developer need to add schema markup manually. This is not difficult, but it requires editing the site's code.

Here is the process:

Step one: Write the JSON-LD schema block

Create a JSON-LD object with all the Restaurant properties. Example:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Restaurant",
  "name": "Your Restaurant Name",
  "image": "https://yoursite.com/images/restaurant-exterior.jpg",
  "servesCuisine": "American",
  "priceRange": "$$",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "25 Route 9 West",
    "addressLocality": "Wilmington",
    "addressRegion": "VT",
    "postalCode": "05363",
    "addressCountry": "US"
  },
  "telephone": "+1-802-464-1234",
  "openingHours": "Tu-Sa 17:00-21:00",
  "url": "https://yoursite.com",
  "menu": "https://yoursite.com/menu"
}
</script>

Replace the placeholder values with your actual restaurant information. Add this block to your HTML, ideally in the <head> section or just before the closing </body> tag.

Step two: Add menu schema (optional but highly recommended)

If you want to mark up your full menu, create a hasMenu property with Menu and MenuItem objects (see the menu schema example earlier). This is tedious but powerful. Many restaurants start with the six core properties and add menu schema later.

Step three: Validate the schema

Use Google's Rich Results Test or a schema validator to check your code. Fix any errors (missing commas, incorrect property names, invalid formats).

Step four: Publish and wait

Once the schema is live, Google and AI tools will read it the next time they crawl your site (usually within a few days to two weeks). Test your visibility by searching for your restaurant and checking whether you appear in AI Overviews.

A Wilmington farm-to-table restaurant with a custom PHP site added schema in January 2025. The developer wrote a JSON-LD block with Restaurant type, servesCuisine: "Farm-to-table", address, phone, hours (Wednesday-Sunday 5-9pm, closed Monday-Tuesday), priceRange: "$$$", and menu schema for 12 signature dishes (with prices and dietary tags for vegetarian and gluten-free items). The schema block was 200 lines of code. It took the developer 3 hours to write and validate. Two weeks after publishing, the restaurant started appearing in Google AI Overviews for "farm-to-table Wilmington VT," "upscale restaurants Wilmington Vermont," and "gluten-free dining Wilmington VT." ChatGPT cited them when tourists asked "where should I get a nice dinner in Wilmington." The 3 hours of developer time paid for itself with one booking.

How to add schema markup if you use WordPress, Wix, or Squarespace

If your restaurant website runs on WordPress, Wix, or Squarespace, you may be able to add schema without touching code by using plugins or built-in features.

WordPress: Use a schema plugin

WordPress does not add Restaurant schema by default, but several plugins can add it for you:

Yoast SEO (free plugin): Yoast has a "Local SEO" add-on (paid, $99/year) that adds LocalBusiness schema. You can configure it to use Restaurant type and add properties like cuisine, hours, and price range. It does not support full menu schema, but it covers the six core properties.

Schema Pro (paid plugin, $79/year): Schema Pro lets you add custom schema types including Restaurant. You can configure all properties (type, cuisine, address, phone, hours, priceRange) and even add basic menu schema. Good for non-technical users who want full control.

WP Schema (free plugin): WP Schema offers a Restaurant schema option. You fill out a form with your restaurant details and the plugin generates the JSON-LD code. Limited menu schema support.

Rank Math (free plugin with paid pro version): Rank Math has a schema builder that supports Restaurant type. The free version covers basic properties. The pro version ($59/year) adds more advanced schema options.

Install one of these plugins, configure the Restaurant schema settings, and validate using Google's Rich Results Test.

Wix: Use Wix's built-in schema tools

Wix automatically adds basic LocalBusiness schema to all business sites, but you need to customize it for restaurants:

Go to your Wix dashboard > Settings > Business Info. Fill out all fields (business name, address, phone, hours). Under "Business Type," choose "Restaurant" (not "Local Business"). Add your cuisine type if the field is available. Wix will generate Restaurant schema based on this info.

Wix does not support custom menu schema natively. If you need menu schema, you may need to add it manually using Wix's custom code feature (Wix dashboard > Settings > Custom Code > Add Code to Head).

Squarespace: Add schema manually or use a code block

Squarespace adds basic LocalBusiness schema automatically, but it does not support Restaurant-specific properties or menu schema out of the box. You need to add custom JSON-LD code:

Go to your Squarespace site editor > Settings > Advanced > Code Injection. In the "Header" section, paste your JSON-LD schema block (the example shown earlier). Save and publish.

Squarespace users often need developer help to write the JSON-LD code correctly because Squarespace's code injection interface is not user-friendly for non-technical users.

A Wilmington pizza restaurant on WordPress installed the Schema Pro plugin ($79/year) in late 2024. The owner filled out the plugin's form (business name, address, phone, cuisine: "Pizza", hours: Monday-Saturday 11am-9pm, priceRange: "$"). The plugin generated Restaurant schema automatically. The owner validated it using Google's Rich Results Test (passed). Two weeks later, the restaurant started appearing in "pizza Wilmington VT" Google AI Overviews and ChatGPT cited them when tourists asked "where can I get pizza near Wilmington Vermont." The $79 plugin was cheaper and faster than hiring a developer.

Why Route 9 corridor restaurants face extra geographic schema challenges

Restaurants along the Route 9 corridor (Wilmington, Marlboro, West Dover, Brattleboro) face a unique geographic challenge: tourists searching for "restaurants in Wilmington VT" may not realize that great restaurants exist a few miles away in West Dover or Marlboro. If your schema only lists your town name (addressLocality: "Marlboro"), Google and AI may not cite you for "restaurants in Wilmington VT" queries even though you are only 8 miles away.

Here is how to fix this:

Add area served (areaServed property)

The areaServed property tells Google and AI which nearby towns or regions you serve. Example:

"areaServed": [
  "Wilmington, VT",
  "West Dover, VT",
  "Marlboro, VT",
  "Brattleboro, VT"
]

This signals to AI that your restaurant is relevant to searches for any of these towns. A tourist searching "restaurants in Wilmington VT" may see your Marlboro restaurant cited because your schema says you serve the Wilmington area.

Mention Route 9 and nearby landmarks in your address or description

Add a description property to your schema that mentions Route 9 or nearby towns. Example:

"description": "Family-owned Italian restaurant on Route 9 between Wilmington and Brattleboro, serving fresh pasta and wood-fired pizza since 2008."

This geographic context helps AI understand your location relative to tourist searches.

Use geo coordinates (latitude/longitude)

Add a geo property with your exact coordinates:

"geo": {
  "@type": "GeoCoordinates",
  "latitude": "42.8654",
  "longitude": "-72.8676"
}

Geo coordinates help Google and AI calculate proximity for "near me" searches and for queries like "restaurants within 10 miles of Wilmington VT."

A Marlboro restaurant 8 miles west of Wilmington added areaServed: ["Wilmington, VT", "Marlboro, VT", "West Dover, VT"] and geo coordinates to their schema in early 2025. Before: they were invisible in "restaurants in Wilmington VT" searches because their addressLocality was "Marlboro" and Google assumed they were not relevant to Wilmington queries. After: Google's AI Overview started citing them as an option "near Wilmington" and ChatGPT mentioned them when tourists asked "where should I eat between Wilmington and Brattleboro." The areaServed property expanded their geographic reach without changing their actual location.

Why reviews mentioning your cuisine and dishes boost schema effectiveness

Schema markup tells Google and AI what you claim to be (a restaurant serving Italian food with gluten-free options). Reviews act as third-party verification. If your schema says servesCuisine: "Italian" and 25 Google reviews mention "great Italian food," "best pasta in Wilmington," "authentic Italian," Google and AI weight your schema as accurate and credible. If your schema says "Italian" but reviews mention burgers and barbecue, AI may distrust your schema and skip you.

Here is what to prompt customers to include in reviews to reinforce your schema:

Mention the cuisine type. "Best Italian food in Wilmington," "Great Mexican restaurant," "Authentic farm-to-table dining."

Mention specific dishes (especially dishes in your menu schema). "The lasagna was incredible," "Grass-fed burger was cooked perfectly," "Gluten-free pancakes were delicious."

Mention dietary options (if you marked them in schema). "Great vegetarian options," "They have a full gluten-free menu," "Vegan-friendly."

Mention price or value (to confirm your priceRange). "Affordable," "Great value for the quality," "Upscale but worth it," "Reasonable prices."

You cannot control what customers write, but you can nudge them. When you ask for a review (via email or text after the meal), include a sentence like: "If you have a moment, we'd love a Google review. It's especially helpful if you mention what you ordered and what you loved about it - it helps other diners know what to try!"

Detailed reviews that align with your schema amplify your AI visibility. Generic reviews ("Great place!") do not.

A Wilmington American restaurant had schema with servesCuisine: "American" and menu schema for their signature burger, mac and cheese, and pot roast. They started asking customers to mention specific dishes in reviews. Over four months, they collected 22 new reviews. Eighteen mentioned specific dishes ("The burger is the best I've had in Vermont," "Mac and cheese was creamy and perfect," "Pot roast was tender and flavorful"). ChatGPT started citing the restaurant more often for queries like "best burger Wilmington VT" and "comfort food Wilmington Vermont" because the reviews confirmed the schema. Before the detailed reviews, ChatGPT cited the restaurant in two out of six queries. After, it was five out of six.

How to test whether your schema is working (and fix it if it's not)

After you add or update your Restaurant schema, test whether Google and AI can read it correctly and whether your visibility improves.

Step one: Validate the schema

Use Google's Rich Results Test (search.google.com/test/rich-results). Enter your homepage URL. Google will show you what schema it found and whether there are errors. Fix any errors (missing properties, incorrect formats, typos).

Step two: Check Google Search Console

If you have Google Search Console set up (free tool, highly recommended), go to Enhancements > Unparsed structured data or Enhancements > Rich results. Google will show you schema-related errors or warnings. Fix them.

Step three: Test your queries in Google and AI

Search for your core queries in Google ("restaurant Wilmington VT," "Italian restaurant Wilmington VT," "breakfast Wilmington VT"). Check whether your restaurant appears in Google's AI Overview (if one is shown). Ask ChatGPT and Perplexity the same queries. Record whether you are cited.

If you are not cited after adding schema, check these common issues:

Schema not indexed yet. Google and AI tools re-crawl sites on different schedules (days to weeks). Wait 2 to 3 weeks and test again.

Schema has errors. Re-validate using Rich Results Test. Fix any errors.

Schema is too generic. Make sure you used type: Restaurant (not LocalBusiness) and added specific properties (cuisine, hours, priceRange, menu).

Your content does not match your schema. If your schema says "Italian" but your website and menu show American food, AI distrusts the schema. Make sure your schema accurately reflects your business.

Competitors have stronger signals. If competitors have schema plus 60+ reviews and you have schema plus 15 reviews, AI may cite them first. Schema helps, but reviews, website quality, and citation volume also matter. (See the local SEO guide for the full picture.)

A West Dover breakfast restaurant added schema in December 2024. They validated it (no errors). They tested queries in Google and ChatGPT two weeks later. Google's AI Overview cited them for "breakfast West Dover VT" but not for "breakfast Wilmington VT." ChatGPT did not cite them at all. The owner checked competitors ChatGPT cited. All had menu schema (the breakfast restaurant had only the six core properties, no menu schema). The owner added menu schema for 10 breakfast items (omelets, pancakes, French toast, breakfast sandwiches, with prices and dietary tags). They tested again three weeks later. Now ChatGPT cited them for "breakfast Wilmington VT" and "gluten-free breakfast near Mount Snow." Menu schema closed the gap.

Why Brattleboro Local sites include Restaurant schema by default

Every restaurant site we build at Brattleboro Local includes full Restaurant schema from day one. We add the six core properties (type: Restaurant, servesCuisine, address, phone, hours, priceRange) and, if the client provides menu details, we add menu schema with MenuItem objects and dietary tags.

This is not an upsell or an add-on. It is built into every custom site because we know schema is the infrastructure that makes restaurants discoverable in AI search. A restaurant website without schema is like a restaurant without a sign on the door. You exist, but nobody can find you.

Our schema setup process:

Kickoff meeting: We ask about your cuisine type, hours, price range, and whether you have dietary options (vegetarian, vegan, gluten-free). We ask whether you want full menu schema or just core properties (full menu schema takes longer but delivers better AI visibility).

Schema build: We write the JSON-LD schema block with all properties and validate it before launch. If you provide a full menu with prices, we mark up the top 12 to 20 items (signature dishes, popular items, dietary-specific items).

Launch and validation: We test the schema using Google's Rich Results Test and make sure it passes. We verify that Google reads it correctly.

Ongoing updates: If your hours change seasonally or if you update your menu, we update the schema as part of your subscription (included, no extra charge). Schema is not set-it-and-forget-it. It needs to stay current.

Schema is invisible to your customers, but it is the most visible thing about your restaurant to Google and AI. We make sure it is done right.

The bottom line: AI cannot cite what it cannot parse, and schema is how you make your restaurant parseable

Google AI Overviews, ChatGPT, and Perplexity are not ranking websites anymore. They are extracting facts from websites and synthesizing answers. If your restaurant website has no structured data, AI has to guess what type of business you are, what you serve, when you are open, and how much you charge. AI is bad at guessing. It skips ambiguous cases and cites competitors whose facts are clearly labeled in schema markup.

This is not a future problem. This is happening right now. Tourists planning trips to Wilmington and the Route 9 corridor are asking Google and ChatGPT where to eat, and AI is citing the restaurants with schema and skipping the restaurants without it. If your restaurant has been in business for 15 years, has great reviews, and serves excellent food, none of that matters if AI cannot parse your website. You are invisible.

Adding schema is not hard. If you have a custom site, you or your developer can write a JSON-LD block in a few hours. If you use WordPress, you can install a plugin for $79/year. If you use Wix or Squarespace, you can configure built-in settings or add custom code. The work is tedious but not complex. The return is immediate: within two to three weeks, you start appearing in AI Overviews and ChatGPT recommendations for queries you were invisible for before.

Every Wilmington and Route 9 corridor restaurant should audit their schema this month. Check whether you have it. Check whether it is complete (Restaurant type, cuisine, address, phone, hours, priceRange, menu). Fix gaps. Validate. Test. Measure. The restaurants that do this work will capture the tourists asking AI where to eat. The restaurants that skip it will lose bookings to competitors they have never heard of, simply because the competitor's website speaks machine language and yours does not.

Schema markup is the new minimum viable infrastructure for restaurant discoverability. If you do not have it, you are not competing in 2025 and beyond. Add it now.

Want to see exactly what structured data your Wilmington restaurant site currently has (or does not have), get a side-by-side comparison of your schema vs. competitors who are dominating AI search, and get a clear action plan for adding or upgrading your schema to capture the tourists asking Google and ChatGPT where to eat? The free 27-point local SEO audit includes a full schema analysis. We check what schema you have, what is missing, what errors exist, and which properties would have the biggest impact on your AI visibility. We also test your core queries in Google AI Overviews, ChatGPT, and Perplexity to show you where you are invisible and which competitors are being cited instead. If you need schema added or upgraded, we explain exactly what it will take and what is included in a custom subscription site (schema is always included, along with hosting, updates, and support). No pitch, just the diagnostic and the roadmap.