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

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.

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.
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.
{
"@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.
<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.
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.
Make the Service markup readable for Bing and AI search
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.
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.
