Schema markup for service businesses (with copy-paste JSON-LD)

Why schema matters for service businesses

Search engines and AI engines read your pages and try to figure out what your business is, what it does, and where it operates. Without schema markup, they infer from the unstructured content: page text, headings, link patterns, address mentions. Inference works but it is noisy and slow.

Schema markup short-circuits the inference. You hand the engine a structured declaration in JSON-LD format, embedded in your page head: this is a foundation repair contractor, located at this address, serving these cities, founded this year, with these credentials. The engine reads the declaration directly and uses it as authoritative.

For service businesses specifically, schema unlocks three benefits.

Local pack ranking. Google weights schema-declared business attributes when calculating local pack relevance. A foundation contractor with full LocalBusiness schema beats one without, holding all other factors equal.

AI citation eligibility. ChatGPT, Perplexity, Claude, and Google AI Overviews preferentially cite content where the underlying entity is unambiguously declared. Schema gives the engine confidence in your facts.

Rich result appearance. FAQ schema can produce expandable Q&A in search results. HowTo schema can produce step lists. Service schema can produce service listings. Each rich result type increases your real estate on the SERP and improves click-through.

The work is concrete. Four schema types, well-deployed, cover most of what a service business needs.

Schema type 1: LocalBusiness

LocalBusiness (or a subtype like GeneralContractor, RoofingContractor, HomeAndConstructionBusiness) is the parent schema for any local service business. It declares the business itself: name, address, phone, hours, service area, founder, and key attributes.

For most service businesses, the appropriate subtype gives you better category alignment than the generic LocalBusiness type. Schema.org provides a hierarchy: LocalBusiness > HomeAndConstructionBusiness > GeneralContractor (or RoofingContractor, ElectricalContractor, etc.). Use the most specific subtype that matches your business.

Here is a working LocalBusiness schema for a foundation repair contractor.

{
  "@context": "https://schema.org",
  "@type": "GeneralContractor",
  "@id": "https://cascadefoundation.com/#business",
  "name": "Cascade Foundation Repair",
  "description": "Residential foundation repair specialist serving Portland, Oregon and surrounding metro areas. Diagnosis and repair of settling, cracking, and structural foundation issues in older homes.",
  "url": "https://cascadefoundation.com",
  "telephone": "+1-503-555-0142",
  "email": "info@cascadefoundation.com",
  "foundingDate": "2008-03-15",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "1200 NE Killingsworth St",
    "addressLocality": "Portland",
    "addressRegion": "OR",
    "postalCode": "97211",
    "addressCountry": "US"
  },
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": 45.5621,
    "longitude": -122.6451
  },
  "areaServed": [
    { "@type": "City", "name": "Portland", "containedInPlace": { "@type": "State", "name": "Oregon" } },
    { "@type": "City", "name": "Beaverton", "containedInPlace": { "@type": "State", "name": "Oregon" } },
    { "@type": "City", "name": "Lake Oswego", "containedInPlace": { "@type": "State", "name": "Oregon" } }
  ],
  "openingHoursSpecification": [
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
      "opens": "07:00",
      "closes": "17:00"
    }
  ],
  "priceRange": "$$",
  "image": "https://cascadefoundation.com/images/yard.jpg",
  "logo": "https://cascadefoundation.com/images/logo.svg"
}

Adapt the values to your business and place this in the head of your homepage. Most CMSes support custom JSON-LD blocks; on Next.js sites, render it in your layout component or per-page metadata.

Schema type 2: Service

Each distinct service you offer should have a Service schema entity, linked back to your LocalBusiness via the provider field. This declares the service-level facts: what the service is, who provides it, where it is offered, what it costs.

Service schema typically lives on the service page itself, not on the homepage. A foundation contractor with three core services has three Service schema entities, one per service page.

Here is a working Service schema for foundation assessment.

{
  "@context": "https://schema.org",
  "@type": "Service",
  "@id": "https://cascadefoundation.com/services/assessment#service",
  "name": "Foundation Assessment",
  "description": "On-site foundation evaluation including written report. Identifies settling, cracking, drainage issues, and provides recommended repair scope with cost ranges.",
  "provider": {
    "@id": "https://cascadefoundation.com/#business"
  },
  "areaServed": [
    { "@type": "City", "name": "Portland", "containedInPlace": { "@type": "State", "name": "Oregon" } },
    { "@type": "City", "name": "Beaverton", "containedInPlace": { "@type": "State", "name": "Oregon" } }
  ],
  "offers": {
    "@type": "Offer",
    "priceSpecification": {
      "@type": "PriceSpecification",
      "minPrice": "350",
      "maxPrice": "500",
      "priceCurrency": "USD"
    }
  },
  "serviceType": "Foundation Assessment",
  "category": "Home Repair"
}

Note the @id reference in the provider field, pointing back to the LocalBusiness defined on the homepage. This creates the entity graph that AI engines use to confirm the relationship between business and services.

Schema type 3: FAQPage

FAQPage schema declares a section of your page as a question-and-answer block. Google uses it to surface FAQ rich results in search and to feed People Also Ask recommendations. AI engines use it to extract direct answers for citation.

For service businesses, FAQPage schema goes on every guide, every service page that has an FAQ section, and the homepage if it has one. Most service business sites can deploy FAQ schema across 10 to 30 pages within a single sprint.

Here is a working FAQPage schema with three questions.

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How much does foundation repair cost in Portland?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Foundation repair in the Portland metro typically costs $4,000 to $18,000 depending on soil conditions, foundation type, and scope. Crack repair runs $800 to $4,500. Helical pier underpinning runs $4,000 to $18,000. Structural repair on older homes can exceed $25,000."
      }
    },
    {
      "@type": "Question",
      "name": "How long does foundation repair take?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Most foundation repair projects complete in 2 to 5 days of on-site work after a 1 to 2 week assessment and engineering phase. Major underpinning or full structural repairs run 1 to 3 weeks of on-site work."
      }
    },
    {
      "@type": "Question",
      "name": "Do you offer warranties on foundation work?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. Crack repair carries a 5-year workmanship warranty. Helical pier underpinning carries a transferable lifetime warranty on the piers themselves and a 10-year warranty on installation."
      }
    }
  ]
}

Place the FAQPage schema in the head of any page with a corresponding FAQ section. The questions and answers in the schema must match the visible content on the page; mismatches trigger Google's structured data warnings and can disqualify the page from FAQ rich results.

Schema type 4: Article

Article schema goes on every long-form post, guide, or case study. It declares the article facts: headline, author, publisher, dates, description.

For service businesses running content marketing, Article schema is required on every guide for FAQ rich result eligibility, AI citation extraction, and basic content authority signaling.

Here is a working Article schema for a service-business guide.

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How long does foundation repair take?",
  "description": "Typical foundation repair timelines from assessment through final inspection, based on 80 projects in the Portland metro since 2020.",
  "author": {
    "@type": "Person",
    "name": "Sam Brown",
    "jobTitle": "Founder",
    "url": "https://cascadefoundation.com/about/sam-brown"
  },
  "publisher": {
    "@id": "https://cascadefoundation.com/#business"
  },
  "datePublished": "2026-03-12",
  "dateModified": "2026-04-15",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://cascadefoundation.com/guide/how-long-does-foundation-repair-take"
  },
  "image": "https://cascadefoundation.com/images/foundation-repair-timeline.jpg"
}

The author field should reference a real person, not the business. Pages with named authors with credentials and bios consistently outperform anonymous content on both Google ranking and AI citation logic.

How to deploy schema

Three implementation paths, depending on your stack.

Native CMS support. WordPress with Yoast or Rank Math handles most schema automatically once you fill in the business information fields. Webflow exposes JSON-LD blocks per page. Shopify handles Product schema natively but needs custom code for LocalBusiness or Service.

Custom-coded sites. Add JSON-LD blocks in the page head as inline script tags with type "application/ld+json". On Next.js, use the built-in metadata API or a custom Script component. Render the JSON-LD per-page based on the content.

Schema generators with manual placement. Tools like Schema.org Generator or Merkle's Schema Markup Generator produce valid JSON-LD that you paste into your CMS or theme. Useful for one-off pages or when CMS-native support is incomplete.

Whichever path, validate every schema deployment in two places: Google's Rich Results Test (search.google.com/test/rich-results) and Schema.org's Validator (validator.schema.org). Both catch different errors. Pages that pass both tests are deployment-ready.

Common schema mistakes

Five mistakes account for most failed schema deployments.

Wrong schema type. Declaring a foundation contractor as Restaurant or Hair Salon (because the schema generator defaulted somewhere) confuses both Google and AI engines. Pick the most specific subtype that matches your business.

Hidden or missing schema content. Schema declares facts. Those facts must appear in the visible page content. Schema that says "foundation repair starts at $4,000" with no corresponding visible mention triggers Google warnings and disqualifies rich results.

Inconsistent business info across schemas. The LocalBusiness phone number on the homepage must match the LocalBusiness phone number referenced from the Service schema on every service page. Use @id references to a canonical LocalBusiness entity instead of repeating fields.

Broken @id references. If you reference @id "https://yourdomain.com/#business" from a Service schema but never declare that @id on any page, the entity graph breaks. Either define the canonical entity once and reference it everywhere, or include the full LocalBusiness object inline.

Skipping validation. Schema that validates technically but contains semantic errors (wrong subtype, broken relationships, missing required fields) underperforms compared to validated schema. Validate every page in the Rich Results Test before considering it deployed.

Maintenance and updates

Schema is not set-and-forget. Three scenarios trigger updates.

Business changes. New phone number, new address, new hours, new categories. Update the LocalBusiness schema everywhere it appears (canonically once, if you used @id references properly).

New services. Each new service offering needs a Service schema on its page, linked back to LocalBusiness. Add as services launch.

Content changes. FAQ pages with updated questions need updated FAQPage schema. Articles with revised content need updated dateModified fields. Most CMSes that handle schema natively update these automatically; custom implementations need explicit refresh.

Annual schema audit. Once a year, run every page through the Rich Results Test and flag any pages with errors or warnings. Schema spec evolves; deprecations occur; new opportunities appear (HowTo schema, ProfessionalService subtypes, Review aggregations). The annual audit catches drift and identifies new opportunities to declare.