Contractor Schema Markup in 2026: The LocalBusiness + Service + FAQ Stack AI Overviews Actually Cite

Pages with proper FAQPage schema are 3.2x more likely to be cited in a Google AI Overview, and contractors using the right LocalBusiness subtype see roughly 2.5x higher inclusion in AI-generated answers from ChatGPT, Perplexity, and Google AI Overviews. That’s the 2026 reality. Schema markup stopped being a “nice to have” the moment AI search engines started citing structured data as the source of truth for entity facts.

A contractor with a sloppy generic LocalBusiness block and no Service or FAQ markup will get out-cited by a competitor running the proper HVACBusiness type, per-city Service schema, and FAQPage on every landing page. The map pack still matters. The Google Business Profile still matters. But the layer that decides whether Google’s AI Overview names you or your competitor when a homeowner asks “who’s the best HVAC company in Plano” is structured data. Most contractors are not yet implementing it correctly.

Why schema matters more in 2026 than it did in 2024

Stackmatix’s 2026 structured data analysis tracked AI citation rates across thousands of queries and found content with proper schema markup has a 2.5x higher chance of appearing in AI-generated answers. That’s the difference between a contractor whose name shows up in the AI Overview for “best plumber [city]” and one whose competitors get cited.

The mechanism is straightforward. AI search engines (Google AI Overview, ChatGPT search, Perplexity, Brave) consume structured data as the authoritative version of what a page says. When the schema declares the business is a Plumber operating in Dallas with 247 reviews and 24-hour emergency service, the AI engine treats that as fact. Without schema, the AI engine has to infer the same facts from unstructured HTML, and the inference is less reliable, which lowers citation odds.

Google’s local business structured data documentation has stayed consistent since 2018 on what to mark up. What changed in 2026 is the downstream consumption. The same JSON-LD block that earned a knowledge panel slot in 2022 now earns AI Overview citations in 2026. Same work, much higher leverage.

Schema.org LocalBusiness subtypes for the trades

The single most common mistake contractors make is using generic LocalBusiness when Schema.org publishes a specific subtype for their trade. The specific type is always better.

Schema.org’s HomeAndConstructionBusiness page lists eight subtypes home service contractors should use:

• HVACBusiness for HVAC, heating, cooling, ductwork
• Plumber for plumbing, drain cleaning, water heater
• Electrician for electrical, panel upgrades, EV charger installs
• RoofingContractor for roofing replacement, repair, gutters
• GeneralContractor for remodels, additions, project management
• HousePainter for interior and exterior painting
• Locksmith for locks, rekeying, security
• MovingCompany for residential and commercial moves

The hierarchy goes Thing > Organization > LocalBusiness > HomeAndConstructionBusiness > [your specific type]. Google’s entity graph reads the deepest applicable type as the strongest signal of what you are.

For contractors who run multiple trades under one roof (plumbing-and-HVAC shops, electrical-and-HVAC), Schema.org supports array syntax: "@type": ["Plumber", "HVACBusiness"]. Both topical signals flow into Google’s understanding of the business. ESEOSpace’s contractor schema guide confirms this is the right pattern for multi-trade operators.

A roofer on r/sweatystartup posted last quarter about switching from "@type": "LocalBusiness" to "@type": "RoofingContractor". No other changes. Within 60 days his knowledge panel pulled in his trade descriptor automatically and his AI Overview citation rate (tracked via SE Ranking) climbed roughly 40%.

The minimum LocalBusiness JSON-LD block for a contractor in 2026:

{
  "@context": "https://schema.org",
  "@type": "Plumber",
  "name": "ABC Plumbing",
  "image": "https://abcplumbing.com/logo.png",
  "@id": "https://abcplumbing.com/#business",
  "url": "https://abcplumbing.com",
  "telephone": "+1-555-123-4567",
  "priceRange": "$$",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "123 Main St",
    "addressLocality": "Dallas",
    "addressRegion": "TX",
    "postalCode": "75201",
    "addressCountry": "US"
  },
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": 32.7767,
    "longitude": -96.7970
  },
  "openingHoursSpecification": [{
    "@type": "OpeningHoursSpecification",
    "dayOfWeek": ["Monday","Tuesday","Wednesday","Thursday","Friday"],
    "opens": "07:00",
    "closes": "19:00"
  }],
  "sameAs": [
    "https://www.facebook.com/abcplumbing",
    "https://www.yelp.com/biz/abc-plumbing-dallas",
    "https://g.page/abcplumbing"
  ]
}

That block belongs in the page head as a single <script type="application/ld+json"> tag on the homepage and about page. Variations appear on every service page with Service schema layered on top.

Service schema with areaServed (per service, per city)

Schema.org’s Service type is what marks up the specific service a page sells. Every service page and every service-area page needs its own Service schema block in addition to the LocalBusiness block.

The properties that matter:

• serviceType: the specific service (“Emergency Drain Cleaning,” “Tankless Water Heater Installation,” “Furnace Repair”)
• provider: references your LocalBusiness via @id
• areaServed: the city or region the page targets (a Place, GeoCircle, AdministrativeArea, or plain Text)
• hasOfferCatalog: optional but useful for listing sub-services within a category

A drain cleaning service page for Dallas:

{
  "@context": "https://schema.org",
  "@type": "Service",
  "serviceType": "Emergency Drain Cleaning",
  "provider": { "@id": "https://abcplumbing.com/#business" },
  "areaServed": {
    "@type": "City",
    "name": "Dallas, TX"
  },
  "description": "24-hour emergency drain cleaning across Dallas. Hydro jetting, camera inspection, sewer line clearing.",
  "offers": {
    "@type": "Offer",
    "priceSpecification": {
      "@type": "PriceSpecification",
      "minPrice": 189,
      "maxPrice": 480,
      "priceCurrency": "USD"
    }
  }
}

The provider reference is the load-bearing piece. It uses the @id from your LocalBusiness block to tell Google these are the same entity. Without that link, Google reads each Service block as an untethered claim. With it, the Service inherits authority from the verified business.

For service-area businesses with no public storefront (most contractors), areaServed is what tells Google which markets you operate in. The karpi.studio areaServed reference walks through the GeoCircle, GeoShape, AdministrativeArea, and Text variants. For most contractors, simple City or AdministrativeArea works.

This pattern scales with service area pages. A contractor with 18 city pages publishes 18 distinct Service schema blocks, one per city, all referencing the same LocalBusiness @id. That’s the entity link that lets pages outside the GBP’s 10-15 mile radius rank.

Review and AggregateRating schema (the policy line)

This is the schema contractors most often misuse and most often get penalized for. Google’s structured data policy is strict.

Google Search Central’s review snippet policy requires that AggregateRating values reflect reviews that are visible on the same page where the schema lives. You cannot pull a 4.9-star count from Google Business Profile and stamp it on your page via AggregateRating schema without the underlying reviews being on the page. That’s a policy violation that can trigger a manual action.

The legitimate pattern:

1. Embed real customer reviews on the page (a testimonials section with at least 3-5 reviews, each with reviewer name, date, body text, star rating).
2. Mark each review with Review schema.
3. Add AggregateRating that sums the on-page reviews honestly.

{
  "@context": "https://schema.org",
  "@type": "Plumber",
  "name": "ABC Plumbing",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "12"
  },
  "review": [
    {
      "@type": "Review",
      "author": { "@type": "Person", "name": "Sarah M." },
      "datePublished": "2026-05-15",
      "reviewBody": "Same-day service for our water heater. Tech arrived in 45 minutes, fair pricing, clean work.",
      "reviewRating": { "@type": "Rating", "ratingValue": "5" }
    }
  ]
}

The reviewCount in the schema should match the count of Review objects on the page. Twelve marked-up reviews, reviewCount 12. Adding "reviewCount": "247" because that’s your Google review total is the exact pattern Google’s spam team penalizes.

A plumber on ContractorTalk posted last year about a manual action that cost him three months of map pack visibility. He had marked his homepage with AggregateRating 4.9 / reviewCount 312 (pulling from his Google profile), with no on-page reviews. Manual action notice in Search Console, full schema removal required, 90 days for the suppression to lift. His takeaway: “The shortcut wasn’t worth the recovery time.”

FAQPage schema (the AI Overview lever)

This is the highest-leverage schema move of 2026.

Frase’s 2026 FAQ schema analysis measured FAQPage schema at a 67% citation rate on relevant question-format queries, with Brand Cited’s research showing FAQ-marked pages are 3.2x more likely to generate a Google AI Overview citation than unstructured content.

Google deprecated the visible FAQ accordion rich result on May 7, 2026. The schema itself is not deprecated. Google’s update was explicit: the company still uses FAQPage schema to understand pages, and every major AI search engine (Google AI Overview, ChatGPT, Perplexity, Brave) parses it as a primary signal for question-answer citation.

For contractors, this means FAQ schema is now more valuable than it was when it earned visible accordions. The visible accordion was nice for click-through. The AI Overview citation is worth orders of magnitude more.

What to mark up:

• 5-8 questions per service page, each with a 2-4 sentence answer
• Questions phrased the way homeowners actually type them (“How much does a water heater installation cost in Dallas?”)
• Answers that include a specific number, price band, or timeline (AI engines cite specifics, not generalities)

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "How much does emergency drain cleaning cost in Dallas?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "Emergency drain cleaning in Dallas runs $189-$480 depending on the severity of the clog and whether hydro jetting is required. Same-day response within 4 hours, evenings and weekends included."
    }
  }]
}

Every service page should carry FAQPage schema. Every service-area page should carry FAQPage schema tuned to that city’s pricing and response time. Eight to twelve FAQ pairs across a typical contractor site is enough to start showing in AI Overview citations within 30-90 days.

Organization schema and sameAs entity confirmation

The Organization schema (or its LocalBusiness equivalent for most contractors) carries one critical property for AI engines: sameAs.

The sameAs array is how you tell Google and AI engines that the entity on your website is the same entity that owns your Google Business Profile, Facebook page, Yelp listing, LinkedIn company page, and trade association profile. This is the entity confirmation that lets AI engines confidently cite you.

"sameAs": [
  "https://g.page/abcplumbing",
  "https://www.facebook.com/abcplumbing",
  "https://www.yelp.com/biz/abc-plumbing-dallas",
  "https://www.bbb.org/us/tx/dallas/profile/plumber/abc-plumbing",
  "https://www.angi.com/companylist/us/tx/dallas/abc-plumbing.htm",
  "https://www.linkedin.com/company/abc-plumbing"
]

This block belongs on the homepage LocalBusiness schema. Include the top 6-10 high-authority profiles that confirm your entity. The same profiles you built during your local SEO citation work become the sameAs array here. The schema work and the citation work compound.

For multi-location contractors, each location should have its own LocalBusiness schema with its own sameAs array pointing to that location’s specific GBP and directory listings, not the corporate parent’s.

JSON-LD vs Microdata: JSON-LD wins, full stop

Google’s documentation has recommended JSON-LD as the preferred format since 2015. In 2026 there’s no reason to use anything else.

JSON-LD lives in a single <script type="application/ld+json"> block in the page head. It doesn’t entangle with rendered HTML, it’s easy to validate, easy to template across pages, easy for the engineering team to maintain. Microdata is the legacy format that wraps schema inline around HTML elements. It worked in 2010; by 2026 it creates maintenance debt because schema breaks every time the page is redesigned.

For Astro, Next.js, WordPress, or any static-generator stack, JSON-LD goes in a head component as a templated script tag. Variables (business name, city, service type) populate from frontmatter or CMS fields.

Validation: Rich Results Test and Schema.org Validator

Two tools. Run both on every page that ships schema.

Google’s Rich Results Test parses the page the way Googlebot parses it and reports which rich result types are eligible. This is what tells you whether your schema is in a format Google actually consumes.

Schema.org’s official validator validates against the full Schema.org spec, catching errors Google’s tool might miss (deprecated properties, type mismatches, invalid enumeration values).

The pattern: build schema, run both validators, fix errors, deploy. For ongoing monitoring, Google Search Console’s “Enhancements” report flags schema errors at the site level once Google crawls the pages. Check it weekly during initial rollout, monthly after.

Sterling Sky recommends running the Rich Results Test against your top 5 ranking competitors before designing your own schema. You see exactly what schema types they use and where your gaps are. Most contractors find 2-3 schema types competitors are running that they’re not.

Common contractor schema mistakes

The five that suppress more visibility than anything else:

Using generic LocalBusiness instead of the specific trade subtype. An electrician using "@type": "LocalBusiness" instead of "@type": "Electrician" leaves topical signal on the table. The deeper type always wins.

AggregateRating with no on-page reviews. Stamping reviewCount: 247 from Google reviews on a page with zero on-page review markup is a policy violation. Manual action territory. The fix is to embed real reviews with Review schema and let AggregateRating sum them honestly.

Missing required fields on LocalBusiness. The required minimum is name, address, phone, and at least one of: image, telephone, openingHours, geo, url, sameAs. Schema missing the basics gets flagged in Search Console as ineligible.

Service schema without provider reference. Marking up a service without "provider": { "@id": "..." } referencing your LocalBusiness leaves the service untethered. Google reads it as an orphan claim. Always link Service back to LocalBusiness via @id.

One giant LocalBusiness block on every page. Schema should reflect what the specific page is about. Homepage gets full LocalBusiness. Service pages get LocalBusiness + Service. FAQ-rich pages add FAQPage. Service-area pages add areaServed-scoped Service. Identical schema on every page tells Google nothing about the page hierarchy.

The schema work compounds with the rest of the local stack. We’ve covered HVAC SEO, plumber SEO, and roofing SEO by trade. The Google Business Profile checklist covers the GBP side. Schema is the structured-data layer that ties all of it into the entity graph.

The honest take

Schema in 2026 is not exotic and not expensive. A competent developer can implement the full LocalBusiness + Service + FAQPage + Organization stack across a 30-page contractor site in 8-12 hours. The marginal cost of schema on a new page (using a templated component) is roughly five minutes.

The payoff is asymmetric. Pages with proper schema get cited 2.5x more often by AI engines. FAQ schema specifically is 3.2x more likely to win an AI Overview citation. Multiply that across every “best [trade] [city]” query a homeowner runs, and the contractor who shipped schema is the contractor whose name shows up in the AI-generated answer.

What contractors should not do: pay $500 to a freelance “schema specialist” to ship a copy-pasted LocalBusiness block on the homepage and call it done. Schema is page-by-page. Service pages need Service schema. Service-area pages need areaServed-scoped Service schema. FAQ-rich pages need FAQPage.

Get the schema right once. Template it. Validate it. Ship it on every page that goes live from there forward. Most contractors will still be running generic LocalBusiness blocks in 2027. The ones who shipped the proper stack in 2026 will already own the AI Overview citations by then.