Put Service structured data on each page that explains one service. Give it a name, description, url, serviceType, provider and areaServed, and give the service its own @id built from the page URL. Point provider at your business node by its @id.

Add an offers object only when the page itself shows a price, an estimate or a price range. If the work needs a quote, say so in visible text and leave Offer.price out.

Key takeaways

  1. One node per service pagePut Service markup on each page that explains one service, with name, description, url, serviceType, provider and areaServed, plus an @id built from the page URL.
  2. Link the providerDescribe the business once in a LocalBusiness node, then point provider at it by @id from every service page.
  3. Add offers carefullyAdd offers only when the page shows a price, estimate or range. If the work needs a quote, say so in visible text and omit Offer.price.
  4. Know the Google featureGoogle's gallery has no dedicated Service feature, but it documents LocalBusiness and requires name and address for it. Service is valid schema.org vocabulary.
  5. Check in four placesCheck JSON syntax, then schema.org vocabulary, then the Rich Results Test for the LocalBusiness part. Inspect the published URL, because a crawler may receive different output.
  6. Update with the pageUpdate the visible text and the Service node in the same change whenever a price, coverage area or service name changes, then inspect the live URL.

Write one Service node for each service page

A Service node describes one thing a business does for customers: a furnace inspection, a bookkeeping package, a tree removal. Schema.org defines Service as a service provided by an organization, and its examples include delivery, printing, consulting, cleaning and repair. The practical rule that follows is one page and one node. If two services are different enough to have different prices, scopes or coverage areas, each gets its own page and its own Service node.

Every value in the node should match something a visitor can read on that page. Google's general structured data guidelines say structured data should represent the visible content of the page, and that misleading or hidden content can keep a page from showing a rich result. Bing's Webmaster Guidelines make a similar statement, adding that misleading markup may be ignored.

A man sits on the tailgate of a landscaping truck typing on a laptop on a folding table, with a clipboard beside him
Figure 1. One page and one Service node for each service the business offers.

Give the node a stable @id. The simplest pattern is the canonical page URL followed by #service, for example https://example.com/services/furnace-inspection/#service. That identifier lets the provider property, an Offer and any other node refer to the service without repeating its details, and it stays the same as long as the page URL does. If you ever move the page, update the @id with it.

Keep the Service and LocalBusiness nodes separate

The two nodes do different jobs. The LocalBusiness node says who the business is, where it is and how to reach it. The Service node says what one page offers and where it is available. The Service node points back to the business through provider, so you describe the business once and reference it from every service page.

The two nodes also follow different rules. The Service node uses schema.org vocabulary. Google's structured data gallery lists features such as Local business, Organization, Product, Event, Article, Breadcrumb and Review snippet, and it has no dedicated Service feature. The LocalBusiness node is different: Google documents it as a feature, and says name and address are required for it, with url, telephone and other fields recommended. Read the Google LocalBusiness documentation for the full list, and the local business schema guide for the business node in depth.

A building card at the top connected to a row of four service cards, with a bracketed markup panel mirroring them
Figure 2. The business node is described once and every service node points back to it.

Use the most specific LocalBusiness subtype that fits the business; Google recommends this. Google also says the markup can go on any page, though a page with information about the business is usually the most appropriate place. If your organization is not tied to a location, the organization schema guide covers the Organization node you would reference from provider instead.

Which fields belong in which node

Hover over or tap a row to highlight it. On small screens the table scrolls sideways.

PropertyNodeStatus
name and addressLocalBusinessRequired for this Google feature
url and telephoneLocalBusinessRecommended for this Google feature
name, description, urlServiceSchema.org vocabulary; no Google Service feature documented
serviceType, provider, areaServedServiceSchema.org vocabulary; keep matched to visible text
offersServiceOptional; add only when the page displays a real price
price and priceCurrencyOfferOptional; only when visible and accurate

The properties a Service node needs

Six properties carry most of the meaning, and each one should be backed by visible text.

The name is the service as the page headline names it. The description is a sentence or two that matches the page's own opening, not a keyword list. The url is the canonical address of the page. The serviceType is the category of the work, in ordinary words such as "residential furnace inspection". The provider is the organization or person that performs the service, normally a reference to your business node. The areaServed is where the service is provided.

For areaServed, schema.org accepts text, a place, an administrative area or a geographic shape. Use the form that matches what the page says. If the page says "serving Example County", an AdministrativeArea named Example County is a close match. If it lists three towns, use an array with one City entry for each. Do not list towns the business does not serve because a longer list looks more impressive.

The seventh property, offers, describes a real offer to provide the service. It is optional, and it belongs only when the page shows a price, an estimate or a range. A rating or review property is optional too, and it belongs only where the page shows genuine, attributable reviews; the review schema guide covers the rules for those.

A complete example with one business and one service

The example below is a single JSON-LD block with two nodes in an @graph. All names, addresses, numbers and prices are fictional and use example.com. It is displayed here as teaching code; never paste example values into a live page, and never add demonstration nodes to your own site's JSON-LD.

json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "LocalBusiness",
      "@id": "https://example.com/#business",
      "name": "Example Home Repair",
      "url": "https://example.com/",
      "telephone": "+1-555-010-0147",
      "address": {
        "@type": "PostalAddress",
        "streetAddress": "100 Example Avenue",
        "addressLocality": "Example City",
        "addressRegion": "IL",
        "postalCode": "60000",
        "addressCountry": "US"
      }
    },
    {
      "@type": "Service",
      "@id": "https://example.com/services/furnace-inspection/#service",
      "url": "https://example.com/services/furnace-inspection/",
      "name": "Residential Furnace Inspection",
      "description": "A visual and operational inspection of a residential furnace for homeowners in Example County.",
      "serviceType": "Residential furnace inspection",
      "provider": {
        "@id": "https://example.com/#business"
      },
      "areaServed": {
        "@type": "AdministrativeArea",
        "name": "Example County"
      },
      "offers": {
        "@type": "Offer",
        "url": "https://example.com/services/furnace-inspection/",
        "price": "180",
        "priceCurrency": "USD",
        "availability": "https://schema.org/InStock",
        "itemOffered": {
          "@id": "https://example.com/services/furnace-inspection/#service"
        }
      }
    }
  ]
}

Replace every value with facts from your own page. The business @id should be a URL you control, and the same @id must appear in the provider reference. The service @id and url should match the real service page. The address fields should match the address your site shows, and the price and priceCurrency should match the price a visitor sees, or the whole offers object should go.

Notice that the Offer points back at the service through itemOffered, using the same @id. That keeps the offer tied to the right node when the graph grows. For the wider pattern of connecting nodes by identifier, the JSON-LD graph guide explains how to build one entity map across pages.

To publish this on a page, wrap the object in a script element. Everything between the tags is exactly the JSON above.

html
<script type="application/ld+json">
{ "@context": "https://schema.org", "@graph": [ ... ] }
</script>

Each service page carries its own Service node. Where you want a consumer to read the business details together with the service, keep the full LocalBusiness node in that page's graph too. A bare provider reference only names the identifier, and it is the full node that holds the address and phone number.

Add the offer only when the page shows a price

An Offer is a statement that the service can be bought or requested on stated terms. That makes it a claim the page has to support. Include price and priceCurrency when the page shows a price a visitor can rely on, such as a flat fee for an inspection. A published range or a clearly explained estimate method can also belong, as long as the page displays it.

Leave the price out when the page does not show one. A starting price that the page does not explain, a guess, or a number that differs from the visible text should not go into markup. When the work needs an inspection or a custom quote, describe that process in visible words, such as "We quote after a site visit", and omit Offer.price. A service node without an offer is complete and valid.

The same restraint applies to everything else the page does not show. Do not add aggregateRating, review, ratingValue or reviewCount unless real, attributable reviews appear on the page. Do not invent customer counts, credentials, availability or guarantees. And do not switch the node to Product to make a service look like something you can ship; use Service for the service and Offer for the commercial terms. Product markup has its own rules, covered in the product schema guide.

Add the markup to your platform

Start by looking at what your site already outputs. Many themes, SEO plugins and site builders add some business or page markup automatically, and a second, conflicting description of the same service helps nobody. View the published page source, search for application/ld+json, and note which types are present. If a Service or LocalBusiness node already exists, update it instead of adding another.

Then use the insertion route your platform documents.

  • WordPress: use a child theme, a custom-code snippet, or a plugin whose own documentation says it outputs JSON-LD for the page type you need. The WordPress schema guide walks through those routes.
  • Wix documents a structured data markup option that accepts manual JSON-LD per page, and it also offers preset markup for some page types.
  • Webflow supports script-based custom code embeds. Custom code is an advanced feature and may depend on your plan.
  • Squarespace documents that it generates several schema types automatically, and describes limited editing of them in its search optimization help. Review what it already produces before planning custom Service markup.
  • Shopify describes how theme structure works. Confirm whether your active theme or a controlled custom-code location can add the JSON-LD without duplicating existing markup.
  • Next.js documents rendering JSON-LD in page or layout components, and recommends sanitizing the serialized string so that a < character cannot break out of the script tag.

For a hand-built site or a Next.js project, a small component per service page keeps the data and the page in step. The sketch below builds the object from the same values the page prints, so the markup cannot drift from the visible text.

js
export default function ServiceJsonLd({ service }) {
  const data = {
    "@context": "https://schema.org",
    "@type": "Service",
    "@id": service.url + "#service",
    url: service.url,
    name: service.name,
    description: service.summary,
    serviceType: service.type,
    provider: { "@id": "https://example.com/#business" },
    areaServed: { "@type": "AdministrativeArea", name: service.area }
  };
  const json = JSON.stringify(data).replace(/</g, "\\u003c");
  return <script type="application/ld+json" dangerouslySetInnerHTML={{ __html: json }} />;
}

Pass the component the same fields that render the page headline, summary and area text. Add the LocalBusiness node separately, on the pages where it belongs. If your site runs on another platform such as HubSpot, confirm the current insertion method in that platform's own documentation or with the site administrator.

Test the markup in four places

Each check answers a different question, so run them in this order. First, confirm the JSON syntax is valid: a missing comma or quote will break everything after it. The Schema Nova validator reports syntax problems and names the line.

Second, check the vocabulary in the Schema Markup Validator, which tests the types and properties against schema.org. Third, run the page through Google's Rich Results Test, which covers the LocalBusiness portion. Do not expect it to report a Service result, because Google does not document one. A clean LocalBusiness result tells you about that node's requirements, not about indexing or display.

Fourth, inspect the published URL, not only the code you pasted. What a crawler receives can differ from what you wrote, because of caching, canonical URLs, access controls or a second plugin adding its own markup. In Search Console, use URL Inspection on the live page. If you use Bing Webmaster Tools, its URL Inspection has a Markup card that recognizes JSON-LD, and Yandex offers a structured data validator that checks Schema.org, Open Graph, microformats, microdata and RDFa.

Bing says it supports schema.org JSON-LD and validates annotated data, so the same Service block serves Bing as well. DuckDuckGo says most of its traditional links are largely sourced from Bing's results. Yandex says it supports Schema.org and JSON-LD but not every Schema.org type, so a valid Service node may not produce a Yandex display.

If you want ChatGPT search to find the page, allow OAI-SearchBot in your robots rules; see OpenAI's crawler documentation. No markup promises a ranking, a rich result or a citation. So, state the service name, provider, coverage area, price and page URL in visible text, keep the URL stable, and let accurate markup say the same thing. The guide on whether AI systems use schema markup has the full comparison.

Keep the markup current

Markup goes stale when a service changes and the page does not. Whenever you edit a price, add a town to the coverage area, rename a service or retire a page, update the visible text and the node in the same change. Then inspect the live URL again.

A test result covers one level: valid JSON, valid schema.org vocabulary, a documented Google feature such as LocalBusiness, or an actual display. They are separate questions. To build the first node without writing the code by hand, use the Service schema generator, and compare its output with your page before you publish. If you run several locations, the multiple locations guide shows how to arrange the business nodes.

From visible page to published markup

  1. Prepare the pageShow the service name, description, coverage area and price (if any) in visible text.
  2. Create the Service nodeAdd name, url, serviceType and an @id built from the page URL.
  3. Link the providerPoint provider at the business node by its @id, then add areaServed.
  4. Add offers carefullyInclude offers only when accurate pricing is visible on the page.
  5. ValidateCheck JSON syntax, schema.org vocabulary, and the LocalBusiness portion separately.
  6. Inspect and maintainInspect the published URL, then recheck when the service, price or coverage changes.

Questions people ask

Does Google have a Service rich result?

Google's structured data gallery lists features such as Local business, Organization, Product, Event, Article, Breadcrumb and Review snippet, and no dedicated Service feature. Google also says eligibility for a documented feature does not guarantee that a rich result appears. A Service node can still describe the page for systems that read schema.org.

Should a service page use Service or Product?

Use Service for work you perform and Offer for the terms on which it is sold. Product describes goods, and switching a service to Product markup only to look like a product misdescribes the page.

What belongs in provider?

The organization or person that performs the service. For a location-based business, reference your LocalBusiness node with provider: {"@id": "..."}, using the same @id the business node carries.

Can I add a price when the service requires a quote?

Only if the page shows a real price, estimate or range. When the price depends on a site visit, explain that in visible text and omit Offer.price. The node stays valid without an offer.

Do website platforms add Service schema automatically?

Some platforms add business, page or product markup on their own. Squarespace, for instance, documents several automatically generated schema types. View the published source and search for application/ld+json before you add anything, so you do not publish two descriptions of one service.

Quick check

Choose an answer to see feedback. Nothing is scored or saved.

Question 1 of 3

Service JSON-LD is valid, but Google's Rich Results Test shows no Service feature. What does that mean?

Question 2 of 3

A page says pricing depends on a site visit. What should the Service node do about price?

Question 3 of 3

Which statement keeps three different meanings apart?

Terms used in Service markup

Select a term to see its definition.

Service. The schema.org type describing a service.