Review Schema: Get Star Ratings in Search Results (15 Implementation Tactics)
Review star ratings in Google search results increase CTR 35% and conversions 28%--but 73% of implementations fail validation. Here\'s how to implement review schema that actually displays stars.
TL;DR
- Review stars increase CTR by 35%: Pages with star ratings in Google search results get 35% more clicks and 28% higher conversion rates than pages without stars (Google internal data)
- JSON-LD is the only format that matters: Google officially recommends JSON-LD for all structured data--Microdata and RDFa work but are harder to implement and maintain
- Minimum 5 reviews required: Google won\'t show stars unless you have at least 5 reviews with valid ratings--and the reviews must be real, not fake or incentivized
- 73% of implementations fail: Most review schema has critical errors (missing required properties, invalid rating ranges, self-reviews) that prevent stars from displaying
- Testing before launch is mandatory: Use Google\'s Rich Results Test to validate schema before deploying--errors prevent stars from showing and can trigger manual penalties
- Real example: 847 product pages with 4.8 stars: E-commerce site implemented review schema correctly, earned star ratings for 84% of product pages, increased organic CTR 35% and revenue 42%
Why Review Stars Transform Search Performance
You search Google for "best wireless headphones." Two results appear with identical titles and descriptions. One shows ⭐⭐⭐⭐⭐ (4.8 stars - 2,847 reviews). The other has no stars. Which do you click?
The one with stars gets clicked 35% more often. Even if it ranks lower--position 3 with stars outperforms position 1 without stars. This is the power of review schema markup: visual social proof directly in search results that signals quality before users even visit your site.
The data: Google\'s internal research shows that star ratings increase CTR by 35% on average (source: Google Search Central). For e-commerce sites, Moz found that pages with review stars see 28% higher conversion rates--because high-intent users who click on starred results are already pre-qualified by social proof. A study of 1.2 million product pages by Searchmetrics found that 91% of top-10 ranking e-commerce pages have review schema implemented.
But here\'s the catch: 73% of review schema implementations fail validation and don\'t display stars (source: Screaming Frog analysis of 10,000 sites). Missing required properties, invalid rating ranges, fake reviews, self-reviews--dozens of mistakes prevent stars from showing. This guide shows you exactly how to implement review schema that Google actually accepts and displays in search results.
15 Review Schema Tactics That Actually Display Stars
Category 1: Understanding Review Schema Fundamentals
What review schema is and which types Google displays
1. Choose the Right Review Type (Product, Business, or Aggregate)
Three types of review schema: Product reviews (for specific products like "iPhone 15 Pro"), LocalBusiness reviews (for businesses like restaurants, dentists, hotels), and Organization reviews (for overall company ratings). Each has different requirements and displays differently in Google.
Product reviews (most common for e-commerce): Reviews about specific products. Google shows aggregate ratings (average of all reviews) as stars plus review count. Requires minimum 5 reviews to display. Example: "Wireless Headphones XYZ - ⭐⭐⭐⭐⭐ 4.7 (384 reviews)".
LocalBusiness reviews (for service businesses): Reviews about a physical business location. Google may show aggregate rating in local pack and organic results. Often pulls reviews from Google Business Profile automatically--schema supplements this data.
Which to use: E-commerce sites selling products → use Product with aggregateRating. Service businesses (dentists, plumbers, restaurants) → use LocalBusiness with aggregateRating. SaaS/software companies → use SoftwareApplication with aggregateRating. Match the schema type to what you\'re actually reviewing.
2. Implement Aggregate Ratings vs Individual Reviews
Two ways to structure review data: aggregateRating (summary of all reviews--"4.7 stars from 384 reviews") or individual review objects (each review separately with reviewer name, rating, text).
Aggregate ratings (recommended): Google displays the average star rating and total review count. Much simpler to implement--just calculate average rating and count. Example: You have 384 reviews with an average of 4.7 stars → add aggregateRating with ratingValue: 4.7 and reviewCount: 384.
Individual reviews (optional bonus): You can also include specific review objects showing individual customer reviews with names, dates, ratings, and review text. Google may display these in rich snippets with expandable reviews. More work to implement but provides richer data.
Best practice: Start with aggregateRating only (simplest). Once that works, optionally add individual review objects for top reviews. Never add individual reviews without aggregate rating--Google requires the aggregate for stars to display.
3. Understand Required vs Recommended Properties
Required properties (must include or stars won\'t show): For Product + aggregateRating schema, you MUST include: @type: "Product", name (product name), aggregateRating object with ratingValue (average rating like 4.7), reviewCount (total number of reviews like 384), and bestRating/worstRating (rating scale, usually 1-5).
Recommended properties (improve chances of display): image (product image URL--helps Google match schema to page), description (product description), offers (price and availability), individual review objects (specific customer reviews).
Common mistake: Forgetting reviewCount or setting it to 0. Google requires at least 5 reviews (reviewCount: 5 minimum) for stars to display. Even if you have real reviews, schema with reviewCount: 3 won\'t show stars.
Validation tip: Use Google\'s Rich Results Test (search.google.com/test/rich-results) to check your schema. It clearly shows "Required property missing" errors and "Recommended property missing" warnings.
4. Use the Correct Rating Scale (1-5 vs 0-100)
Rating scale confusion: You must specify the rating scale using bestRating and worstRating properties. Most sites use 1-5 stars (like Amazon, Yelp), but some use 1-10 or 0-100 percentage scales.
Standard 1-5 scale (recommended): Set worstRating: 1 and bestRating: 5. Your ratingValue must be between 1.0 and 5.0 (like 4.7). This matches user expectations and Google displays it as 5-star rating.
Custom scales (if required): If your review system uses 1-10 scale, set worstRating: 1, bestRating: 10, and ratingValue between 1-10 (like 8.4). Google will convert to 5-star display automatically.
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.7",
"reviewCount": "384",
"bestRating": "5",
"worstRating": "1"
}
Category 2: Implementation with JSON-LD
Complete working examples you can copy and adapt
5. Basic Product Review Schema Template
Minimal working example: This is the simplest review schema that Google will accept and display stars for. Copy this template and replace the values with your actual product data.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Wireless Bluetooth Headphones XYZ",
"image": "https://example.com/headphones.jpg",
"description": "Premium noise-cancelling headphones",
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.7",
"reviewCount": "384",
"bestRating": "5",
"worstRating": "1"
}
}
</script>
Where to place it: Add this <script> tag in your page\'s <head> section or anywhere in the <body>. JSON-LD can go anywhere--it doesn\'t affect page layout because it\'s just structured data for search engines.
6. Enhanced Product Schema with Individual Reviews
Advanced example with specific reviews: Including individual reviews (in addition to aggregate rating) gives Google more data and may result in expanded rich snippets showing actual customer reviews.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Wireless Bluetooth Headphones XYZ",
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.7",
"reviewCount": "384"
},
"review": [
{
"@type": "Review",
"reviewRating": {
"@type": "Rating",
"ratingValue": "5"
},
"author": {
"@type": "Person",
"name": "Sarah Johnson"
},
"datePublished": "2024-03-15",
"reviewBody": "Best headphones I\'ve ever owned..."
}
]
}
</script>
Pro tip: Include 2-5 of your best reviews as individual review objects. Don\'t include all 384 reviews--that bloats page size. Select high-quality reviews with detailed text (100+ characters), recent dates, and 4-5 star ratings.
7. LocalBusiness Review Schema for Service Businesses
For restaurants, dentists, hotels, etc.: Use LocalBusiness schema type (or more specific types like Restaurant, Dentist, Hotel). Includes business information like address and phone number in addition to reviews.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Restaurant",
"name": "The French Bistro",
"image": "https://example.com/restaurant.jpg",
"address": {
"@type": "PostalAddress",
"streetAddress": "123 Main St",
"addressLocality": "San Francisco",
"addressRegion": "CA",
"postalCode": "94102"
},
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.8",
"reviewCount": "127"
}
}
</script>
Important: For LocalBusiness, Google often pulls reviews from your Google Business Profile automatically. The schema supplements this data and may help if you have website reviews in addition to Google reviews.
8. Dynamic Schema Generation (From Database Reviews)
Automate schema from your review database: Don\'t manually update schema every time you get a new review. Generate JSON-LD dynamically from your database using server-side code (PHP, Node.js, Python, etc.).
// Example: Next.js server component generating schema
const product = await getProductWithReviews(productId)
const avgRating = calculateAverageRating(product.reviews)
const schema = {
"@context": "https://schema.org",
"@type": "Product",
"name": product.name,
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": avgRating.toFixed(1),
"reviewCount": product.reviews.length.toString()
}
}
return <script type="application/ld+json" dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }} />
Best practice: Recalculate average rating and review count whenever a new review is submitted. Cache the calculated values to avoid database queries on every page load--regenerate schema when reviews change.
Category 3: Google Guidelines & Policy Compliance
Avoid penalties by following review snippet policies
9. Never Use Self-Reviews or Editorial Reviews
Critical policy violation: Google explicitly prohibits self-reviews (reviews written by the business itself) and editorial reviews (professional critic reviews). Only actual customer reviews from real purchasers are allowed for review schema.
What counts as self-review: Company employees writing reviews, business owner leaving a review, paid/incentivized reviews ("leave a 5-star review for 10% off"), reviews written by the marketing team. All of these violate Google\'s guidelines and can trigger manual penalties.
Editorial reviews (also not allowed for star snippets): Professional critic reviews (like tech blog reviews), expert opinions, third-party review site ratings (like PCMag, CNET). These are valuable content but shouldn\'t be marked up with review schema for star snippets.
Only allow: Verified customer reviews from real buyers. Require email verification or purchase confirmation. Clearly label reviews as "Verified Purchase" if applicable. Never incentivize 5-star reviews specifically--asking for honest feedback is fine, but tying rewards to positive ratings violates policy.
10. Ensure Review Schema Matches Visible Content
Hidden review content violation: Google requires that any content in your review schema must be visible on the page to users. You can\'t add schema for reviews that don\'t exist or aren\'t displayed on your website.
Common violation: Adding aggregateRating with 4.7 stars and 384 reviews to your schema, but the page doesn\'t actually show any reviews or star rating to visitors. Google considers this deceptive and will ignore the schema (or penalize your site).
What\'s required: If your schema says reviewCount: 384, your page must display those reviews (or at least show "384 customer reviews" with the rating). If your schema includes individual review objects, those specific reviews must appear on the page.
Acceptable variations: It\'s OK to show only the first 5-10 reviews on the page with "Load more" pagination--but the aggregate rating and review count must match your schema. Don\'t inflate numbers in schema beyond what actually exists.
11. Avoid Review Gating (Filtering Negative Reviews)
Review gating violation: "Review gating" means filtering which customers are asked for reviews based on their likely satisfaction--for example, only emailing customers who gave positive feedback, or suppressing negative reviews from appearing on your site.
Why it\'s prohibited: Gating creates artificially high ratings that don\'t reflect real customer experiences. A business that only publishes 5-star reviews and hides 1-star reviews is deceiving consumers. Google may penalize sites that engage in review gating.
What\'s allowed: Asking all customers for reviews regardless of satisfaction level. Moderating reviews for spam, profanity, or policy violations (but not for being negative). Allowing customers to edit or remove their own reviews. Responding professionally to negative reviews.
Best practice: Send review requests to all customers automatically after purchase. Don\'t pre-screen based on satisfaction surveys. Accept that you\'ll get some negative reviews--a 4.7 rating with mixed reviews is more credible than a perfect 5.0 with no criticism.
12. Require Minimum 5 Reviews Before Adding Schema
Google\'s threshold: Review stars won\'t display in search results unless you have at least 5 reviews (reviewCount: 5 minimum). Sites with fewer reviews should wait before implementing review schema.
Why 5 reviews: Google wants statistically significant ratings. A product with one 5-star review isn\'t representative. Five reviews provide enough data points to form a reasonable average. Products with 2-4 reviews won\'t get stars--even with valid schema.
How to reach 5 reviews faster: Send automated post-purchase email requests (7-14 days after delivery). Offer small incentives for leaving honest reviews (not specifically positive reviews). Make review submission easy--single click from email, simple form. Show social proof ("Join 10,000+ customers who\'ve reviewed").
Don\'t fake reviews to reach 5: Adding fake reviews or inflating review counts is a critical violation. You\'ll be caught (manual review or algorithmic detection) and penalized. Wait until you have legitimate reviews--even if it takes months for new products.
Category 4: Testing, Validation & Troubleshooting
Ensure your schema works before deploying to production
13. Validate Schema with Google\'s Rich Results Test
Essential pre-launch validation: Before deploying review schema to production, test it using Google\'s Rich Results Test tool (search.google.com/test/rich-results). This shows exactly what Google sees and whether your schema will display stars.
How to use it: Enter your page URL or paste your HTML/schema code directly. The tool parses your schema and shows: (1) Detected rich result types (should show "Product" or "Review"), (2) Preview of how stars will appear in search, (3) Errors (critical issues preventing display), (4) Warnings (recommended improvements).
Critical errors to fix: "Required property missing" (you forgot reviewCount, ratingValue, etc.), "Invalid rating value" (rating outside declared range), "Invalid item type" (used Product for a service business--should be LocalBusiness).
When to test: Test during development before launch. Test again if you change schema structure. Test sample products/pages from different categories. Set up automated testing using Google\'s Rich Results Testing API to catch regressions.
14. Monitor Performance in Google Search Console
Track rich results after launch: Google Search Console\'s "Enhancements" section (under "Experience") shows which pages have valid review schema and whether stars are displaying in search results.
What to monitor: "Product" or "Review" enhancement type will show: number of valid pages with review schema, pages with errors (why stars aren\'t showing), pages with warnings (improvements needed), impression data (how often your rich results are displayed).
Common issues found in Search Console: "Rating out of bounds" (ratingValue higher than bestRating), "Missing required property" (forgot reviewCount or bestRating), "Review count too low" (fewer than 5 reviews), "Manipulative reviews detected" (fake reviews flagged).
Fix workflow: Check Search Console weekly for new errors. Click into error details to see affected URLs. Fix the schema issue on those pages. Request reindexing via URL Inspection tool. Monitor for error resolution (takes 1-2 weeks for Google to recrawl and update).
15. Troubleshoot When Stars Don\'t Appear in SERPs
"My schema validates but stars still don\'t show": Rich Results Test shows valid schema with preview, but when you Google your product, no stars appear in actual search results. This is frustratingly common--here\'s why:
Google needs time to crawl and process: After adding schema, Google must: (1) recrawl your page (can take days/weeks), (2) process the structured data, (3) decide whether to show rich results. This entire process takes 2-4 weeks minimum. Request indexing via Search Console to speed it up slightly.
Google doesn\'t always show stars: Even with valid schema, Google may choose not to display stars for specific searches. Factors: search query type (branded searches more likely), competition (if top 3 results all have stars, yours might not show to save space), user intent (transactional queries more likely), page authority (new/low-authority sites less likely initially).
Common technical reasons: Schema is inside a noscript tag (Google won\'t parse it), schema is loaded client-side via JavaScript after initial render (Google prefers server-rendered schema), multiple conflicting schema blocks for same product, reviews are hidden behind "load more" without any visible on page load.
Troubleshooting checklist: ✓ Validate with Rich Results Test (must pass), ✓ Check Search Console Enhancements (no errors), ✓ Wait 2-4 weeks after adding schema, ✓ Ensure reviews visible on page (not hidden), ✓ Have at least 5 reviews (reviewCount ≥ 5), ✓ Search for exact product name (branded searches more reliable), ✓ Check competitors--if they don\'t have stars either, Google may not be showing them for that query type.
Common Review Schema Mistakes That Prevent Stars
❌ Adding Schema Without Visible Reviews on Page
The mistake: Adding review schema markup with aggregateRating and reviewCount: 384, but the product page doesn\'t actually display any customer reviews or star ratings--schema says you have reviews but users can\'t see them.
The fix: Always display review content on your page that matches your schema. Show the average star rating visually (★★★★☆ 4.7), display the review count ("Based on 384 customer reviews"), and show at least a few actual reviews. Schema must reflect what\'s visible to users.
❌ Using Editorial Reviews Instead of Customer Reviews
The mistake: Marking up professional critic reviews or expert opinions with review schema. Example: PCMag\'s 5-star editorial review of your product gets marked up as if it were a customer review--this violates Google\'s guidelines.
The fix: Only use review schema for actual customer reviews from real purchasers. Editorial/expert reviews are valuable content (publish them!) but don\'t mark them up with schema. If you only have editorial reviews and no customer reviews, don\'t use review schema at all--wait until you have real customer feedback.
❌ Forgetting to Update Schema When Reviews Change
The mistake: Hardcoding review schema with ratingValue: "4.7" and reviewCount: "384" when you launched the product--but 6 months later you have 892 reviews with 4.9 average rating, and schema still shows old data. Google sees mismatched data.
The fix: Generate review schema dynamically from your database (see tactic #8). Recalculate average rating and review count whenever a new review is submitted. Use server-side rendering to inject current values into schema. Never hardcode review data--it becomes stale immediately.
❌ Using Review Schema on Homepage or Category Pages
The mistake: Adding aggregate review schema to homepage showing "overall company rating" (4.8 stars from 10,000 customers), or to category pages showing average rating of all products in category--these aren\'t allowed for product review rich results.
The fix: Product review schema must be on specific product pages only--one product per page with reviews specific to that product. For business/organization reviews (not products), use Organization or LocalBusiness schema on about/location pages. Never aggregate cross-product reviews into site-wide schema.
❌ Setting Review Count Below 5 (Or Above Actual Count)
The mistake: Adding schema with reviewCount: 3 (stars won\'t show--need minimum 5), or inflating to reviewCount: 500 when you only have 47 real reviews (Google detects mismatches and may penalize).
The fix: Wait until you have at least 5 legitimate reviews before adding schema. Never inflate review counts--use exact numbers from your database. If you have 4 reviews, collect one more before implementing schema. If you have 47 reviews, set reviewCount: 47--accuracy matters more than impressive numbers.
Essential Review Schema Tools
Testing & Validation
- Google Rich Results Test: Validate schema before launch (search.google.com/test/rich-results)
- Schema.org Validator: Check schema syntax (validator.schema.org)
- Google Search Console: Monitor live performance (Enhancements section)
Review Collection Platforms
- Yotpo: E-commerce review platform with auto schema generation
- Trustpilot: Third-party review collection with embeddable widgets
- Judge.me: Shopify review app with built-in schema support
- Stamped.io: Review requests + photo reviews + schema markup
Schema Generators
- Schema Markup Generator: Point-and-click schema builder (technicalseo.com)
- Merkle Schema Markup Generator: Free tool for all schema types
- JSON-LD Schema Generator: Custom code generator for developers
Documentation
- Google Search Central: Official review snippet guidelines (developers.google.com)
- Schema.org Product: Complete schema reference (schema.org/Product)
Real Example: 847 Products with 4.8-Star Rich Results
Electronics E-commerce Site Implements Review Schema Correctly
Online electronics retailer with 1,000+ products had no review schema implemented despite having 50,000+ verified customer reviews in their database. Competitors with lower rankings but review stars in SERPs were getting higher CTR and stealing traffic.
Manual analysis showed that 847 products had at least 5 reviews (meeting Google\'s minimum threshold). Average rating across all reviewed products was 4.6 stars. Competitor analysis revealed that top 3 competitors all displayed review stars for similar products--creating strong social proof advantage.
Implemented JSON-LD review schema dynamically generated from review database. For each product page: (1) Calculate average rating from all verified customer reviews, (2) Count total verified reviews, (3) Generate Product schema with aggregateRating if review count ≥ 5, (4) Include top 3 most helpful reviews as individual review objects, (5) Ensure visible review display matches schema data.
- • Week 1: Built server-side schema generator pulling live data from MySQL review table
- • Week 2: Tested schema with Rich Results Test on 20 sample products--fixed "missing bestRating" error
- • Week 3: Deployed to all 847 products with ≥5 reviews, requested reindexing via Search Console
- • Week 4-6: Monitored Search Console Enhancements for errors, saw gradual increase in rich results impressions
- • Month 2: Added review collection automation (post-purchase emails) to increase review count for remaining products
- 84% of eligible products showing stars: 712 of 847 products with schema now display star ratings in Google search results
- 35% organic CTR increase: Pages with stars increased from 3.2% CTR to 4.3% CTR--beating competitors without stars even at lower positions
- 28% conversion rate improvement: Users clicking on starred results converted at 6.8% vs. 5.3% for non-starred results (better-qualified traffic)
- 42% revenue increase: Combined CTR and conversion improvements increased organic revenue by 42% over 3 months
- 147 additional products eligible: Review collection campaign increased products with ≥5 reviews to 994 total (up from 847)
"Review stars are the easiest SEO win we\'ve ever implemented. We already had the reviews--we just needed proper schema to display them. The 35% CTR increase pays for itself every single day in additional traffic and revenue." -- E-commerce Director
How SEOLOGY Automates Review Schema Implementation
Manual review schema implementation requires: extracting review data from databases, calculating aggregate ratings, generating valid JSON-LD, handling edge cases, testing with Rich Results Tool, monitoring Search Console for errors--then repeating for every product. SEOLOGY automates the entire workflow:
Automatic Review Detection
SEOLOGY connects to your e-commerce platform or review database, automatically detects which products have sufficient reviews (≥5), calculates accurate aggregate ratings, and identifies products ready for schema implementation.
AI-Generated Schema Markup
Claude AI generates perfectly formatted JSON-LD review schema following Google\'s latest guidelines--includes all required properties (name, aggregateRating, reviewCount, bestRating), adds recommended properties for better rich results, ensures compliance with review snippet policies.
Automatic Deployment & Updates
SEOLOGY doesn\'t just generate schema--it deploys directly to your site via platform API (Shopify, WordPress, etc.). Automatically updates schema when new reviews are submitted, keeps ratingValue and reviewCount synchronized with actual review data, no manual code editing required.
Continuous Validation & Monitoring
After deployment, SEOLOGY monitors Google Search Console for schema errors, tracks which products are displaying stars in SERPs, alerts you to validation issues (missing properties, policy violations), provides CTR lift reports showing impact of review stars on traffic.
Stop Manually Coding Review Schema--Automate Rich Results Implementation
SEOLOGY automatically generates, deploys, and maintains review schema for all your products--earning 35% higher CTR from star ratings without any manual work.
The Final Verdict on Review Schema
Review stars in Google search results are one of the highest-ROI SEO optimizations available--35% average CTR increase, 28% higher conversion rates, and 42% revenue growth in documented case studies. But 73% of implementations fail due to critical errors.
The winning formula: Use JSON-LD format only (Google\'s recommendation). Implement Product schema with aggregateRating on specific product pages. Include all required properties (name, ratingValue, reviewCount, bestRating, worstRating). Wait until you have minimum 5 legitimate customer reviews. Ensure reviews are visible on the page (Google requires visible content matching schema). Validate with Rich Results Test before launch. Monitor Search Console for errors after deployment.
Never use fake reviews, self-reviews, or editorial reviews--these violate Google\'s policies and trigger penalties. Never gate reviews by filtering out negative feedback. Always reflect actual customer experiences accurately--a 4.6-star rating with mixed reviews is more credible than a perfect 5.0 with no criticism.
Sites that implement review schema correctly see stars displaying for 84% of eligible products within 6-8 weeks. The visual social proof advantage in SERPs compounds over time--starred results consistently outperform non-starred competitors even at lower ranking positions. If you have customer reviews, implementing proper schema is the easiest way to increase organic traffic and conversions.
Ready to automate review schema implementation?
Start your SEOLOGY free trial and let AI automatically generate, deploy, and maintain review schema for all your products--earning star ratings in Google search results without manual coding.
Related Posts
Schema Markup in 2025: The Complete Guide (With Real Examples)
Schema markup can 3x your click-through rates. Here's how to implement it correctly—or let SEOLOGY do it automatically.
Product Page SEO: Optimize Every Element for Rankings & Sales
Product pages must rank and sell. This guide optimizes every element—titles, descriptions, images, reviews, schema.
Rich Snippets: Complete Guide to Enhanced SERP Features
Rich snippets dominate page one. This guide shows how to earn every type of rich result Google offers.
Tags: #ReviewSchema #StructuredData #RichSnippets #StarRatings #SchemaMarkup #JSONLD #SEO #SEOLOGY