Review & Rating Intelligence for Hospitality & Retail Chains – Technical Tutorial

Introduction

Hospitality and retail brands depend heavily on customer feedback across platforms like:

• Google Maps
• Yelp
• TripAdvisor
• Zomato
• Swiggy
• Trustpilot
• Booking.com
• Agoda

For large brands such as:

• Starbucks
• McDonald’s
• KFC
• Domino’s
• Marriott
• Hilton
• Holiday Inn
• Sephora
• H&M
• Walmart

… Reviews determine:

• brand perception
• NPS score
• store-level performance gaps
• consumer sentiment
• operational issues (wait time, hygiene, service)
• product-specific complaints
• recommendations & expectations

This tutorial shows how Actowiz Solutions builds end-to-end Review & Rating Intelligence Pipelines using:

• Selenium for dynamic scraping
• Requests for HTML/API responses
• NLP for sentiment modeling
• Topic clustering
• Star-rating normalization
• Chain-store grouping
• Geo-level review scoring

Step 1: Install Required Libraries

pip install selenium
pip install undetected-chromedriver
pip install requests
pip install beautifulsoup4
pip install pandas
pip install textblob
pip install nltk
pip install sklearn
pip install lxml

We’ll scrape from:

• Google Maps
• Yelp
• TripAdvisor

You can extend this to Zomato/Swiggy easily.

Step 2: Define Target Chain (Example: Starbucks)

We will collect reviews from multiple locations.

Google Maps query: https://www.google.com/maps/search/Starbucks/

Yelp query: https://www.yelp.com/search?find_desc=Starbucks

TripAdvisor query: https://www.tripadvisor.com/Search?q=Starbucks

Step 3: Scrape Google Maps Reviews (Store-by-Store)

3.1 Launch Undetected Chrome

import undetected_chromedriver as uc
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from time import sleep

browser = uc.Chrome()
browser.get("https://www.google.com/maps/search/starbucks/")
sleep(5)

3.2 Scroll left-pane to load more locations

scrollable = browser.find_element(By.CLASS_NAME, "m6QErb")

for _ in range(60):
    browser.execute_script("arguments[0].scrollTop = arguments[0].scrollHeight", scrollable)
    sleep(1.5)

3.3 Extract Store Cards

cards = browser.find_elements(By.XPATH, '//div[contains(@class, "Nv2PK")]')
gm_locations = []

3.4 Parse store-level info

for c in cards:
    try: name = c.find_element(By.CLASS_NAME, "qBF1Pd").text
    except: name = ""

    try: rating = c.find_element(By.CLASS_NAME, "MW4etd").text
    except: rating = ""

    try: reviews = c.find_element(By.CLASS_NAME, "UY7F9").text
    except: reviews = ""

    try: address = c.find_element(By.CLASS_NAME, "rllt__details").text
    except: address = ""

    try: url = c.find_element(By.TAG_NAME, "a").get_attribute("href")
    except: url = ""

    gm_locations.append({
        "store_name": name,
        "rating_summary": rating,
        "review_count": reviews,
        "address": address,
        "url": url
    })

Step 4: Extract Detailed Google Reviews for Each Store

4.1 Visit Each Store URL

gm_reviews = []

for loc in gm_locations[:20]:  # limit for tutorial
    browser.get(loc["url"])
    sleep(4)

4.2 Click “Reviews”

try:
    btn = browser.find_element(By.XPATH, '//button[contains(@aria-label,"reviews")]')
    btn.click()
    sleep(3)
except:
    continue

4.3 Scroll review panel

panel = browser.find_element(By.CLASS_NAME, "m6QErb")

for _ in range(40):
    browser.execute_script("arguments[0].scrollTop = arguments[0].scrollHeight", panel)
    sleep(1)

4.4 Extract Reviews

cards = browser.find_elements(By.XPATH, '//div[@data-review-id]')

for r in cards:
    try: author = r.find_element(By.CLASS_NAME, "d4r55").text
    except: author = ""

    try: rating = r.find_element(By.CLASS_NAME, "fzvQZe").get_attribute("aria-label")
    except: rating = ""

    try: text = r.find_element(By.CLASS_NAME, "wiI7pd").text
    except: text = ""

    try: date = r.find_element(By.CLASS_NAME, "rsqaWe").text
    except: date = ""

    gm_reviews.append({
        "platform": "Google Maps",
        "store": loc["store_name"],
        "rating": rating,
        "review_text": text,
        "date": date,
        "author": author,
        "address": loc["address"]
    })

Step 5: Yelp Review Scraping (Chain-Level)

5.1 Open Yelp Search

browser.get("https://www.yelp.com/search?find_desc=Starbucks")
sleep(4)

5.2 Extract Business Cards

cards = browser.find_elements(By.XPATH, '//div[contains(@class,"container")]')
yelp_locations = []

5.3 Parse Yelp Listing

for c in cards:
    try: name = c.find_element(By.CLASS_NAME, "css-1egxyvc").text
    except: continue

    try: rating = c.find_element(By.CSS_SELECTOR, '[aria-label$="star rating"]').get_attribute("aria-label")
    except: rating = ""

    try: reviews = c.find_element(By.CLASS_NAME, "reviewCount").text
    except: reviews = ""

    try: url = c.find_element(By.TAG_NAME, "a").get_attribute("href")
    except: url = ""

    yelp_locations.append({
        "store_name": name,
        "rating_summary": rating,
        "review_count": reviews,
        "url": url
    })

Step 6: Extract Yelp Reviews Store-by-Store

yelp_reviews = []

for loc in yelp_locations[:20]:
    browser.get(loc["url"])
    sleep(4)
Scroll:
for _ in range(20):
    browser.find_element(By.TAG_NAME, "body").send_keys(Keys.END)
    sleep(1)
Extract reviews:
blocks = browser.find_elements(By.XPATH, '//li[contains(@class,"review")]')

for b in blocks:
    try: text = b.find_element(By.CLASS_NAME, "comment").text
    except: text = ""

    try: rating = b.find_element(By.XPATH, './/div[contains(@aria-label,"star rating")]').get_attribute("aria-label")
    except: rating = ""

    try: date = b.find_element(By.CLASS_NAME, "css-chan6m").text
    except: date = ""

    yelp_reviews.append({
        "platform": "Yelp",
        "store": loc["store_name"],
        "rating": rating,
        "review_text": text,
        "date": date
    })

Step 7: TripAdvisor Review Scraping

TripAdvisor is key for hospitality brands like:

• hotels
• restaurants
• resorts

7.1 Open Search Page

browser.get("https://www.tripadvisor.com/Search?q=Starbucks")
sleep(4)

7.2 Extract Listing URLs

ta_links = browser.find_elements(By.XPATH, '//a[contains(@class,"review_count")]')
trip_urls = [a.get_attribute("href") for a in ta_links]

7.3 Scrape Reviews From Each Property

ta_reviews = []

for url in trip_urls[:10]:
    browser.get(url)
    sleep(4)

    blocks = browser.find_elements(By.XPATH, '//div[contains(@data-test-target,"review")]')

    for b in blocks:
        try: text = b.find_element(By.CLASS_NAME, "QewHA").text
        except: text = ""

        try: rating = b.find_element(By.CSS_SELECTOR, "svg[aria-label]").get_attribute("aria-label")
        except: rating = ""

        try: date = b.find_element(By.CLASS_NAME, "euPKI").text
        except: date = ""

        ta_reviews.append({
            "platform": "TripAdvisor",
            "rating": rating,
            "review_text": text,
            "date": date
        })

Step 8: Combine All Reviews Into One Dataset

import pandas as pd

df = pd.DataFrame(gm_reviews + yelp_reviews + ta_reviews)
df.head()

Step 9: Normalize Ratings

Different platforms have different rating formats:

• Google: “4.3”
• Yelp: “4.0 star rating”
• TripAdvisor: “5 bubbles”

Let's convert everything to a 5-point scale.

import re

def clean_rating(val):
    nums = re.findall(r"\d+\.?\d*", val)
    return float(nums[0]) if nums else None

df["rating_num"] = df["rating"].apply(clean_rating)

Step 10: NLP-Based Sentiment Analysis

from textblob import TextBlob

df["sentiment"] = df["review_text"].apply(lambda x: TextBlob(x).sentiment.polarity)

Sentiment scale:

• +1 → very positive
• 0 → neutral
• -1 → very negative

Step 11: Identify Negative Themes (Complaint Mining)

Define complaint keywords:

keywords = {
    "service": ["slow", "rude", "bad service"],
    "cleanliness": ["dirty", "unclean", "messy"],
    "price": ["expensive", "overpriced"],
    "taste": ["bad taste", "not good", "cold food"],
    "waiting": ["long wait", "delay"]
}

Extract occurrences:

for cat, words in keywords.items():
    df[f"kw_{cat}"] = df["review_text"].apply(
        lambda x: any(w.lower() in x.lower() for w in words)
    )

Step 12: Chain-Level Intelligence Outputs

Average Rating by Platform

df.groupby("platform")["rating_num"].mean()

Sentiment Trend

df.groupby("platform")["sentiment"].mean()

Complaint Heatmap

complaints = df[
    ["kw_service","kw_cleanliness","kw_price","kw_taste","kw_waiting"]
].sum()

Store-Level Score

store_scores = df.groupby("store")["sentiment"].mean()

Step 13: Export the Final Review Intelligence Dataset

df.to_csv("hospitality_review_intelligence.csv", index=False)

Scaling This System for Large Chains

Actowiz deploys systems capable of:

• 10,000+ stores per month
• 5M+ reviews per quarter
• multi-country scraping
• review tracking alerts
• sentiment shifts detection
• competitor comparison

Scaling strategies:

• Proxy rotation
• Split scraping across containers
• Queue-based parallel review extraction
• Store-level retry logic
• Platform-specific optimizations
• Kafka → S3 → Redshift pipelines

Technical Challenges

Actowiz uses:

• browser fingerprinting
• machine-learning–based DOM selectors
• custom Google review decoders
• automated bot-detection avoidance

Conclusion

In this full tutorial, you learned how to:

• scrape reviews from Google, Yelp, TripAdvisor
• extract store-level details
• normalize different rating systems
• run sentiment analysis
• detect complaint categories
• calculate store & brand-level scores
• export analytics datasets
• scale review intelligence for large hospitality & retail brands

This forms the backbone of a Review & Reputation Intelligence Platform used by global enterprise clients of Actowiz Solutions.

You can also reach us for all your mobile app scraping, data collection, web scraping , and instant data scraper service requirements!