Anyone who has searched in the last few years for "carpenter", "tax advisor", or "hair salon" in any given city knows the picture. Between the classic blue search results, certain entries show a block with stars, a review count, and sometimes even opening hours or a price range. These enhanced snippets measurably attract more clicks than the bare entries next to them. They are what Google calls "rich results", and for local businesses they are the only mechanism that boosts both SEO and SERP perception at the same time, without you having to change anything about your actual ranking.
In this post I will show how rich snippets for local SEO actually work, what you need in your page's HTML, how the interplay with the Google Business Profile looks, and why the naive assumption "I maintain my GBP and Google handles the rest" simply does not produce SERP stars.
What are rich snippets in a local SEO context?
Rich snippets are enhanced search results that Google generates from structured data in your page's HTML. Instead of just title, URL, and snippet text, Google additionally shows stars, review count, price range, opening hours, address, and sometimes a photo.
For local businesses, three rich-result types are particularly relevant.
LocalBusiness stars. The yellow star rating below the search title, plus the review count in parentheses. "Bauer Carpentry, ★★★★★ (247)". The source is an AggregateRating property inside a LocalBusiness or Organization schema.
Address and phone in the snippet. On mobile search, Google often shows local results with address, opening hours, and a call button directly inside the snippet. The source is the PostalAddress structure plus openingHours in the LocalBusiness schema, supplemented by Google Business Profile data.
Breadcrumb path instead of URL. Instead of the often cryptic URL example-firm.com/subpage/blah, Google shows the readable path "example-firm.com > Service > Carpentry". The source is BreadcrumbList schema.
All three types work completely independently of your actual ranking. You can sit in position 7 and still have a much more click-worthy snippet than position 3 without schema. That makes rich snippets probably the best lever in local SEO, measured by effect per unit of effort.
Why is the Google Business Profile alone not enough?
A lot of local businesses think: "My GBP is well maintained, I have reviews, opening hours, and photos. Local SEO done." That is only half right.
The Google Business Profile (GBP) populates the Local Pack and the Maps results. When someone searches "carpenter Cologne", Google shows the map view at the top with three pins and map snippets. That is GBP territory. If your profile sits there, you have won that slot.
What GBP does not directly control are the organic search results below the Local Pack. Those are the classic blue hits, and that is exactly where you need schema on your own website so Google renders stars next to your entry. Without schema in your page's HTML, the stars do not show up there, no matter how good your GBP profile looks.
Example: you run a carpentry shop in Cologne, your GBP profile has 247 reviews with a 4.8 average. For the query "carpenter Cologne" you sit:
- In the Local Pack with stars from GBP. Excellent.
- In the organic results at position 6, with a bare URL and no stars. Suboptimal.
If you then serve clean LocalBusiness schema with AggregateRating on your page, Google also pulls the stars for the organic entry. Your snippet gets the same visual trust boost as the Local Pack, and your CTR climbs by an estimated 20 to 35 percent. That is the effect most local sites overlook.
What schema do you actually need?
The minimum schema for local rich snippets is LocalBusiness with embedded AggregateRating and PostalAddress. A complete, valid example:
{
"@context": "https://schema.org",
"@type": "LocalBusiness",
"@id": "https://muster-firma.de#business",
"name": "Schreinerei Bauer",
"url": "https://muster-firma.de",
"telephone": "+49 221 1234567",
"priceRange": "$$",
"address": {
"@type": "PostalAddress",
"streetAddress": "Hauptstraße 12",
"postalCode": "50667",
"addressLocality": "Köln",
"addressRegion": "Nordrhein-Westfalen",
"addressCountry": "DE"
},
"geo": {
"@type": "GeoCoordinates",
"latitude": 50.9375,
"longitude": 6.9603
},
"openingHoursSpecification": [
{
"@type": "OpeningHoursSpecification",
"dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
"opens": "08:00",
"closes": "17:00"
}
],
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.8",
"reviewCount": "247"
}
}
Three points are critical.
First: AggregateRating has to be embedded, not standalone. If you write AggregateRating as its own top-level schema without a parent, Google sees the pattern "rating without a thing being rated" and ignores it. Embedded inside LocalBusiness is mandatory.
Second: addressCountry as an ISO-2 code. "Germany" or "DE" both work, but Google parses ISO-2 more reliably. Write "DE" instead of "Germany".
Third: PostalAddress structured, not as a string. Some plugins generate "address": "Hauptstraße 12, 50667 Köln, Germany" as a single string. That is not valid. PostalAddress with separate fields for streetAddress, postalCode, addressLocality, addressRegion, and addressCountry is required.
When you validate with Google's Rich Results Test, you will see immediately whether your schema meets these points. If not, the test will report either errors or warnings. Errors prevent rich results, warnings usually allow them but suggest improvements.
How does the schema actually get onto your page?
Three ways, depending on your tech stack.
WordPress with a dedicated plugin. Plugins that automatically write LocalBusiness schema into wp_head are the easiest route. You connect your Google Business Profile, the plugin pulls address, phone, price range, and reviews, and builds the schema from that. We built our own because audits kept turning up the same three problems: API keys leaking in the frontend, schema conflicts with Yoast or RankMath, and very inconsistent freshness of review data across plugins. If you are looking for a single plugin that solves LocalBusiness schema plus rich snippets cleanly, you can find the details on the rich snippets page. Similar plugins exist from other vendors. What matters are the three properties mentioned above.
WordPress with an SEO plugin (Yoast, RankMath, AIOSEO). If you are already using an SEO plugin, it usually writes Organization or Article schema, often also a generic LocalBusiness. In the premium tier of Yoast or RankMath you can configure address, opening hours, and phone. Stars from real Google reviews are usually not delivered directly by these plugins because the GBP connection is not integrated. Workaround: a separate reviews plugin alongside Yoast or RankMath that only adds the AggregateRating property.
Static sites, headless CMS, custom builds. With Hugo, Next.js, Webflow, or custom backend stacks you have to render the JSON-LD schema yourself. Put a <script type="application/ld+json"> block in the page's <head> with the content from the example above. You pull the review data either at build time from the Google Places API or via server-side rendering with a cache. Avoid direct calls from the browser, otherwise your API key ends up publicly in the HTML.
In all three cases, validation with the Rich Results Test is the final word. If it recognizes the schema and reports no critical errors, you did it right.
Try it for free: The yourseo visibility check at yourseo.app shows you in one step which schema types are already detected on your domain and which are missing. Plus a concrete recommendation for which schemas would have the biggest lever for your page type.
When do the stars actually show up?
This question frustrates most site operators implementing schema for the first time. They activate the plugin, validate in the Rich Results Test, everything green. A week later there is still nothing visible in the real SERP. What is going on?
Three factors come into play.
Crawl frequency. Google has to crawl your page with the new schema once before it even knows about the data. On active sites this happens within hours to a few days, on small local sites it can take two weeks. Search Console shows the last crawl date per URL under "URL inspection".
Render decision per query. Even when Google knows the schema, it decides per query whether stars in the snippet make sense. Queries like "best carpenter Cologne" are commercial intent, so Google shows stars more often there. Queries like "wood properties" are informational, so stars appear less often. You do not influence this directly.
Spam score and domain trust. Google is strict with AggregateRating because it is one of the most manipulated schema fields. If your domain is new, has little trust, or trips anti-spam signals, Google will see the schema but decide against showing it. With time and more authentic reviews, the trust comes.
Expectation management: count on two to six weeks from going live with the schema to a steady star display in the SERP. Anyone saying "it does not work" after three days is being impatient.
Rich snippets are not a ranking factor (in the strict sense)
An important point that many people misunderstand: rich snippets do not directly improve your ranking. A page at position 7 with stars does not suddenly leap to position 3 just because it has stars. What happens is different. The stars raise the click-through rate from the SERP, and a higher CTR is, over time, an indirect ranking signal.
The chain of effect: schema markup goes to stars in the SERP, which lifts CTR by 20 to 30 percent at position 7, which means more clicks, which Google reads as elevated user interest, which over months turns position 7 into position 5 or 4, which means even more clicks.
That is the long-term story. The short-term one is simpler. Stars pull clicks, more clicks mean more inquiries, and that goes straight into revenue. Anyone who also captures the long-term effect gets a bonus on top.
Common mistakes in local schema implementations
From more than a hundred audits of local business sites, I keep seeing four pitfalls.
Multiple LocalBusiness schemas on one page. When your theme, your SEO plugin, and an additional schema plugin all three output a LocalBusiness block, Google sees three different versions and in the worst case takes none of them seriously. Solution: one schema owner per domain. If you use Yoast, let Yoast write the schemas and disable other plugin schemas.
Address mismatch between schema and Google Business Profile. The schema says "Hauptstraße 12", the GBP says "Hauptstr. 12, entrance B". This NAP inconsistency (name, address, phone) is one of the most classic local SEO offenses. Google measures consistency across every reachable data source. Make sure the address in your schema, in the website footer, in GBP, and in external directories is identical, word for word.
AggregateRating without real reviews. Some plugins let you enter a ratingValue and reviewCount by hand. That is dangerous. Google's structured-data spam policy explicitly bans fabricated reviews. If it gets caught, you get a manual action in Search Console that kills all rich results for your domain. Reviews must come from a genuine source, ideally directly from the connected GBP profile.
Schema only on the homepage. Many site operators only serve LocalBusiness schema on the start page. That is a beginning, but it is suboptimal. Service pages, landing pages, and contact pages should also serve LocalBusiness (ideally with the same @id so Google links the entities). That way deeper-ranking pages also get stars in the SERP, not just the homepage.
What else is possible beyond stars
LocalBusiness schema is the foundation. Anyone wanting to get more out of rich snippets can layer on additional schema types.
Event schema for appointments, workshops, sales events. Google shows these as a carousel or as an event snippet with date, address, and a "buy tickets" link. Works particularly well for restaurants, workshops with open-house days, and coaching providers.
FAQPage schema for common customer questions. Google renders the questions directly below the snippet as an expandable list. It pulls attention in the SERP and often answers search intent before the click. Caveat: these have to be real FAQs on the page, not invented.
Service schema for individual services. Useful when your business offers several clearly distinct services (for example "custom furniture", "restoration", "wood construction"). Each service page gets its own Service schema, ideally linked to the central LocalBusiness schema via the provider property.
Product schema for local providers with their own product range. If you sell furniture, every product image in the webshop has a Product schema that can output prices, availability, and reviews. Less important for purely local-oriented providers, mandatory for e-commerce-leaning businesses.
In practice, the right entry point is LocalBusiness plus AggregateRating. The other schemas come later, once the foundation is running cleanly.
Interplay with reviews widgets
If you already embed a reviews widget with real Google ratings, you have already done half the work. The data in the widget (aggregate score, review count) is exactly what belongs in the schema. A widget that also outputs JSON-LD covers both requirements at once.
If you only use a widget without schema output, you are giving up half the effect. The widget shows the stars on the page, but Google sees no structured data and does not serve stars in the SERP. Before buying or installing a widget, always check: is schema markup included in the feature set? If not, it is the wrong widget.
The reverse problem also exists. A schema plugin without a widget shows Google the stars, but not the visitors on the page. You lose the conversion effect on the landing page. The clean solution is an integrated setup: widget plus schema output from a single source.
Measuring and adjusting
Once the schema is live, you need a measurement routine, otherwise you have no idea if it is working.
First: regular Rich Results Test. Once a month, click through your most important service pages and verify that the schema still validates. WordPress updates or plugin updates can break schema silently.
Second: CTR comparison in Search Console. Filter under "Performance" to the queries where your page appears with rich results in the SERP. Compare before and after the schema implementation. A CTR lift of 20 to 40 percent at the same position is the typical order of magnitude.
Third: conversion tracking. If review stars in the SERP raise CTR by 30 percent, the number of inquiries via the service page should also climb. If it does not, you have a conversion problem on the page itself, not a SERP problem.
Anyone checking these three points quarterly captures the full local SEO value from rich snippets and notices early when something goes sideways.
Conclusion
Rich snippets are probably the fastest and most measurable lever in local SEO. Six weeks from going live with schema to seeing the first stars in the SERP, then 20 to 40 percent more clicks at the same ranking position. The wiring diagram is clear. GBP for the Local Pack, schema on your own site for the organic stars. Both together produce full local SEO visibility. Either one alone always leaves an effect on the table.
The technical implementation is not trivial, but not extremely complex either. LocalBusiness schema with embedded AggregateRating is the minimum setup. Done right, it validates cleanly in the Rich Results Test, does not conflict with other SEO plugins, and uses real review data from GBP rather than hand-maintained values.
Once the foundation is solid, Event, FAQ, and Service schemas come as the next steps. But first the foundation. Stars in the SERP are the point where your local SEO becomes visible without your ranking having to move at all.