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

Picture a Wilmington restaurant owner Googling her own business and finding something strange. Her restaurant appears in the old-style search results (ten blue links), but when Google shows its AI Overview (the AI-generated summary box at the top of results), her restaurant disappears. A tourist searching "restaurants in Wilmington VT" sees an AI Overview listing a few restaurants. Hers is not one of them. She has good Google reviews and years in business, plus a website with menu and hours. But Google's AI cannot clearly tell what type of business she is, so it skips her.

In a case like this, the problem is often not the content or the reviews or the reputation. It is structured data. Her website has 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 can see the website (a human can read it fine), but it has a harder time extracting structured facts from plain paragraphs of text. A competitor the AI does cite has schema markup on their site (invisible code that labels everything for machines). The AI reads that markup and extracts the facts instantly. Then it cites the competitor.

This can happen 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. That holds even if your food is better and your reviews are stronger.

This post explains what structured data is and why Google and AI tools require it to cite restaurants. It covers the 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) 555-1234, 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 and tries to figure out what type of business you are. It tries to extract hours from a sentence like "We're open most evenings for dinner, give us a call." It 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.

For example, say a Wilmington breakfast spot has 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 can read that and know exactly what the business is. But when the owner searches "breakfast Wilmington VT," Google's AI Overview lists other breakfast spots. Running the cited competitors through a schema checker shows they all have schema markup. The next step is Restaurant schema on her own site (type: Restaurant, servesCuisine: Breakfast, address, phone, hours, priceRange, menu), then testing the same search again in a couple of weeks.

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) 555-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) 555-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-555-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 enables 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-555-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 enable 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.

Consider a Wilmington Italian restaurant whose website has only LocalBusiness schema (type: LocalBusiness, name, address, phone). No cuisine, no hours, no price range. When tourists search "Italian restaurant Wilmington VT," AI tools have no structured signal that it serves Italian food at all. Upgrading to Restaurant type with servesCuisine: "Italian", the full address, phone, structured hours (Tuesday-Saturday 5-9pm), priceRange: "$$", and menu schema (see next section) gives Google's AI Overview and ChatGPT exactly the facts they need to match it to "where should I get Italian food in Wilmington Vermont."

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 and what they cost. It also shows 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 that you serve a burger ($16) and a vegetarian/vegan stir-fry ($18), plus 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.

Say a Wilmington cafe has a breakfast and lunch menu on its website (omelets, pancakes, sandwiches, salads) as plain HTML text, no schema. When tourists search "gluten-free breakfast Wilmington VT," the cafe may not appear even though it has gluten-free pancakes and bread, while a competitor that marks gluten-free items explicitly in menu schema gets cited instead. Adding menu schema for its most popular items, with gluten-free and vegetarian options marked, opens up a whole category of dietary-specific queries like "where can I get a vegetarian breakfast in Wilmington Vermont."

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.

For example, a Wilmington barbecue restaurant running the Rich Results Test might find only LocalBusiness schema with name, address, and phone. No type: Restaurant. No cuisine. No hours. No menu. That means it is being read as a generic local business, and Google and AI have no structured signal that it serves barbecue or when it is open. The fix: upgrade to Restaurant type and add servesCuisine: "Barbecue", hours, priceRange: "$$", and basic menu schema for the most popular items (pulled pork, brisket, ribs, with prices), then re-run the test to confirm every property shows up.

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-555-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.

For a sense of scale: a farm-to-table restaurant's 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 a dozen signature dishes (with prices and dietary tags for vegetarian and gluten-free items) might run a couple hundred lines of code and take a developer a few hours to write and validate. That is the kind of markup that matches searches like "farm-to-table Wilmington VT," "upscale restaurants Wilmington Vermont," and "gluten-free dining Wilmington VT."

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 and configure the Restaurant schema settings. Then 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.

For example, a Wilmington pizza place on WordPress could install a schema plugin, fill out its form (business name, address, phone, cuisine: "Pizza", hours: Monday-Saturday 11am-9pm, priceRange: "$"), let the plugin generate Restaurant schema, and confirm it with Google's Rich Results Test. For a simple setup, that can be 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."

For example, a Marlboro restaurant a few miles from Wilmington whose addressLocality is "Marlboro" may be invisible in "restaurants in Wilmington VT" searches, because nothing tells Google it is relevant to Wilmington. Adding areaServed: ["Wilmington, VT", "Marlboro, VT", "West Dover, VT"] and geo coordinates gives AI tools a reason to mention it as an option "near Wilmington" or when tourists ask "where should I eat between Wilmington and Brattleboro." areaServed widens the geographic reach without changing the 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.

Say a Wilmington American restaurant has schema with servesCuisine: "American" and menu schema for its signature burger, mac and cheese, and pot roast. If it starts asking customers to mention what they ordered, many new reviews will name specific dishes ("the burger," "the mac and cheese," "the pot roast"). Reviews like that confirm the schema, which makes it easier for ChatGPT to cite the restaurant for queries like "best burger Wilmington VT" and "comfort food Wilmington Vermont."

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 if 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.)

Here is a typical pattern. Say a West Dover breakfast restaurant adds the six core properties and validates them (no errors). After two weeks, Google's AI Overview cites it for "breakfast West Dover VT" but not for "breakfast Wilmington VT," and ChatGPT does not cite it at all. Checking the competitors ChatGPT does cite shows they all have menu schema. Adding menu schema for its breakfast items (omelets, pancakes, French toast, breakfast sandwiches, with prices and dietary tags) and testing again a few weeks later is the logical next step.

Where a Brattleboro Local site fits

Schema works best on top of a clear website: the right business name, the real address and phone, your hours, your menu with prices, and the towns you serve, written in plain language a person and a machine can both read.

That is what Brattleboro Local builds, for $499 a year, everything included. You tell us about your restaurant on a form, and we write six pages from it: home, about, your menu, the areas you serve, answers to common questions, and contact. The site runs on your own domain, with hello@ your domain forwarded to the email you already use, and hosting, security and backups kept current all year. Pages are built phone-first to read well and load fast for diners, with your number one tap away. You get a login to change any menu item, price, photo, or your hours yourself, so the site stays current through the seasons.

To be clear about scope: the $499 site does not include online ordering, reservation systems, or ranking guarantees. Whatever site you have, run it through the Rich Results Test. Then use the steps in this post to fill any schema gaps. Your restaurant site goes live once it is built, and we make any change you ask for. See the details or start your site.

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 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: in 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 really competing today. Add it now.

Start with the free tools in this post. Run your homepage through Google's Rich Results Test and compare what you find with the six core properties and menu schema above. Then test your core queries in Google, ChatGPT, and Perplexity. If you need a clear, phone-friendly website underneath it all, see what a $499-a-year Brattleboro Local site includes. Or start your site.