Scraping Hospital and Clinic Reviews for Patient Sentiment Analysis

By /

Scraping Hospital and Clinic Reviews for Patient Sentiment Analysis

Patient reviews and ratings have become one of the most influential factors in healthcare decision-making. When choosing a hospital, clinic, or doctor, patients increasingly turn to online reviews for guidance. For healthcare providers, these reviews contain invaluable feedback about service quality, staff performance, facility conditions, and overall patient experience.

Collecting and analyzing patient reviews at scale enables healthcare organizations to monitor their reputation, benchmark against competitors, identify areas for improvement, and understand patient sentiment trends across different markets.

This guide covers how to scrape hospital and clinic reviews from various platforms and apply sentiment analysis techniques to extract actionable insights, using mobile proxies to ensure reliable data collection.

Why Patient Reviews Matter in Healthcare

For Healthcare Providers

  • Reputation management: Understand how patients perceive your services across platforms
  • Quality improvement: Identify recurring complaints and areas needing attention
  • Staff performance: Track mentions of specific departments, doctors, or service areas
  • Competitive benchmarking: Compare patient satisfaction against nearby competitors
  • Marketing intelligence: Discover what patients value most to inform marketing messaging

For Healthcare Investors and Analysts

  • Due diligence: Assess patient satisfaction before investing in healthcare companies
  • Market positioning: Understand which providers lead in patient satisfaction by market
  • Growth indicators: Track review volume and sentiment trends as indicators of business health

For Insurance Companies

  • Network quality assessment: Evaluate provider quality for network inclusion decisions
  • Claims correlation: Compare patient sentiment with claims and outcomes data
  • Provider tiering: Inform tiered network structures based on patient satisfaction

Review Data Sources in Southeast Asia

Google Maps Reviews

Google Maps is the largest source of hospital and clinic reviews across Southeast Asia. Virtually every healthcare facility has a Google Business Profile with patient reviews.

Advantages: Massive volume, consistent format, available in all SEA markets

Challenges: Rate limiting, dynamic content loading, anti-bot protections

Facebook Page Reviews

Facebook remains the dominant social platform in Southeast Asia. Many hospitals and clinics maintain active Facebook pages with patient reviews and recommendations.

Advantages: High engagement in SEA markets, detailed patient stories

Challenges: Privacy settings, dynamic loading, platform restrictions

Specialized Healthcare Review Platforms

  • Practo: Doctor and clinic reviews popular in several Asian markets
  • Halodoc (Indonesia): Patient reviews for telemedicine consultations
  • DoctorOnCall (Malaysia): Reviews for online and offline consultations
  • Doctor Anywhere: Reviews across multiple SEA markets
  • RateMDs and Healthgrades: International review platforms

Medical Tourism Review Sites

  • Medical Departures: Reviews from international patients
  • Dental Departures: Dental tourism reviews
  • What Clinic: Cosmetic and medical procedure reviews
  • Treatment Abroad: International patient experiences

App Store Reviews

Healthcare apps receive reviews that reflect both the digital experience and the underlying healthcare service quality.

Setting Up Review Collection Infrastructure

Proxy Requirements

Review collection requires mobile proxies for several reasons:

  1. Google Maps rate limiting: Google aggressively limits automated access to review data
  2. Geo-specific reviews: Reviews in different countries appear differently based on user location
  3. Platform restrictions: Facebook and other platforms detect and block datacenter IPs
  4. Language and content variations: Local mobile IPs ensure you see reviews in local languages

DataResearchTools mobile proxies provide authentic local access in all six major SEA markets, ensuring comprehensive review collection.

Core Collection Framework

import requests
from bs4 import BeautifulSoup
from datetime import datetime
import json
import time
import re

class ReviewCollector:
    def __init__(self, proxy_user, proxy_pass):
        self.proxies = {
            "SG": f"http://{proxy_user}:{proxy_pass}@sg-mobile.dataresearchtools.com:8080",
            "TH": f"http://{proxy_user}:{proxy_pass}@th-mobile.dataresearchtools.com:8080",
            "ID": f"http://{proxy_user}:{proxy_pass}@id-mobile.dataresearchtools.com:8080",
            "PH": f"http://{proxy_user}:{proxy_pass}@ph-mobile.dataresearchtools.com:8080",
            "MY": f"http://{proxy_user}:{proxy_pass}@my-mobile.dataresearchtools.com:8080",
            "VN": f"http://{proxy_user}:{proxy_pass}@vn-mobile.dataresearchtools.com:8080"
        }

    def get_proxy(self, country):
        proxy_url = self.proxies.get(country)
        return {"http": proxy_url, "https": proxy_url}

    def collect_google_reviews(self, place_id, country):
        """Collect reviews from Google Maps for a healthcare facility"""
        proxy = self.get_proxy(country)
        reviews = []

        # Use Google Maps internal API endpoints
        headers = {
            "User-Agent": "Mozilla/5.0 (Linux; Android 14; SM-S918B) "
                          "AppleWebKit/537.36 (KHTML, like Gecko) "
                          "Chrome/120.0.0.0 Mobile Safari/537.36",
            "Accept-Language": self.get_language(country)
        }

        try:
            response = requests.get(
                f"https://www.google.com/maps/place/?q=place_id:{place_id}",
                proxies=proxy,
                headers=headers,
                timeout=30
            )

            if response.status_code == 200:
                reviews = self.parse_google_reviews(response.text)
                for review in reviews:
                    review["source"] = "google_maps"
                    review["place_id"] = place_id
                    review["country"] = country
                    review["collected_at"] = datetime.utcnow().isoformat()

        except Exception as e:
            print(f"Error collecting Google reviews: {e}")

        return reviews

    def get_language(self, country):
        lang_map = {
            "SG": "en-SG,en;q=0.9",
            "TH": "th-TH,th;q=0.9,en;q=0.8",
            "ID": "id-ID,id;q=0.9,en;q=0.8",
            "PH": "en-PH,en;q=0.9,fil;q=0.8",
            "MY": "ms-MY,ms;q=0.9,en;q=0.8",
            "VN": "vi-VN,vi;q=0.9,en;q=0.8"
        }
        return lang_map.get(country, "en-US,en;q=0.9")

Collecting from Healthcare Platforms

def collect_platform_reviews(self, platform_config, country):
    """Collect reviews from healthcare booking platforms"""
    proxy = self.get_proxy(country)
    all_reviews = []

    for provider in platform_config["providers"]:
        try:
            response = requests.get(
                provider["review_url"],
                proxies=proxy,
                headers={
                    "User-Agent": "Mozilla/5.0 (Linux; Android 14)",
                    "Accept": "application/json"
                },
                timeout=30
            )

            if response.status_code == 200:
                reviews = platform_config["parser"](response.text)
                for review in reviews:
                    review["provider_name"] = provider["name"]
                    review["provider_type"] = provider["type"]
                    review["platform"] = platform_config["name"]
                    review["country"] = country
                    review["collected_at"] = datetime.utcnow().isoformat()
                    all_reviews.append(review)

            time.sleep(2)
        except Exception as e:
            print(f"Error collecting from {provider['name']}: {e}")

    return all_reviews

Sentiment Analysis for Healthcare Reviews

Basic Sentiment Classification

from textblob import TextBlob

class HealthcareSentimentAnalyzer:
    def __init__(self):
        self.healthcare_lexicon = self.build_healthcare_lexicon()

    def analyze_sentiment(self, review_text):
        """Analyze sentiment of a healthcare review"""
        # Basic polarity analysis
        blob = TextBlob(review_text)
        base_sentiment = blob.sentiment.polarity

        # Healthcare-specific sentiment adjustment
        healthcare_score = self.healthcare_specific_score(review_text)

        # Combined score
        final_score = (base_sentiment * 0.6) + (healthcare_score * 0.4)

        return {
            "text": review_text[:200],
            "base_sentiment": base_sentiment,
            "healthcare_sentiment": healthcare_score,
            "final_score": final_score,
            "classification": self.classify(final_score),
            "aspects": self.extract_aspects(review_text)
        }

    def classify(self, score):
        if score > 0.3:
            return "positive"
        elif score < -0.3:
            return "negative"
        return "neutral"

    def build_healthcare_lexicon(self):
        return {
            "positive": [
                "caring", "professional", "clean", "efficient",
                "friendly", "knowledgeable", "thorough", "gentle",
                "patient", "attentive", "compassionate", "skilled",
                "modern", "hygienic", "responsive", "excellent",
                "recommended", "comfortable", "painless", "quick"
            ],
            "negative": [
                "rude", "long wait", "dirty", "expensive",
                "unprofessional", "negligent", "careless", "crowded",
                "slow", "unresponsive", "overcharged", "misdiagnosed",
                "painful", "uncomfortable", "infection", "mistake",
                "incompetent", "unsanitary", "dismissive", "ignored"
            ]
        }

Aspect-Based Sentiment Analysis

Extract sentiment for specific healthcare aspects:

def extract_aspects(self, review_text):
    """Extract sentiment for specific healthcare aspects"""
    aspects = {
        "doctors": {
            "keywords": ["doctor", "physician", "specialist", "consultant",
                        "surgeon", "dr", "dokter", "แพทย์"],
            "mentions": [],
            "sentiment": None
        },
        "nurses_staff": {
            "keywords": ["nurse", "staff", "receptionist", "assistant",
                        "perawat", "พยาบาล"],
            "mentions": [],
            "sentiment": None
        },
        "wait_time": {
            "keywords": ["wait", "waiting", "queue", "delay", "hours",
                        "tunggu", "antri", "รอ"],
            "mentions": [],
            "sentiment": None
        },
        "cleanliness": {
            "keywords": ["clean", "dirty", "hygiene", "sanitary",
                        "bersih", "kotor", "สะอาด"],
            "mentions": [],
            "sentiment": None
        },
        "cost": {
            "keywords": ["price", "cost", "expensive", "cheap", "bill",
                        "affordable", "mahal", "murah", "แพง"],
            "mentions": [],
            "sentiment": None
        },
        "facilities": {
            "keywords": ["facility", "equipment", "room", "building",
                        "modern", "old", "fasilitas", "อุปกรณ์"],
            "mentions": [],
            "sentiment": None
        }
    }

    sentences = review_text.split(".")
    for sentence in sentences:
        sentence_lower = sentence.lower()
        for aspect_name, aspect_data in aspects.items():
            for keyword in aspect_data["keywords"]:
                if keyword in sentence_lower:
                    blob = TextBlob(sentence)
                    aspect_data["mentions"].append({
                        "sentence": sentence.strip(),
                        "sentiment": blob.sentiment.polarity
                    })
                    break

    for aspect_name, aspect_data in aspects.items():
        if aspect_data["mentions"]:
            scores = [m["sentiment"] for m in aspect_data["mentions"]]
            aspect_data["sentiment"] = sum(scores) / len(scores)

    return aspects

Multi-Language Sentiment Analysis

Southeast Asian reviews come in multiple languages. Handle this with translation or multilingual models:

class MultiLanguageSentiment:
    def __init__(self):
        self.language_map = {
            "SG": "en",
            "TH": "th",
            "ID": "id",
            "PH": "en",
            "MY": "ms",
            "VN": "vi"
        }

    def detect_language(self, text):
        """Simple language detection based on character sets"""
        if re.search(r'[\u0E00-\u0E7F]', text):
            return "th"
        if re.search(r'[\u1E00-\u1EFF]', text):
            return "vi"
        # Check for Bahasa Indonesia/Malay common words
        id_words = ["sangat", "baik", "tidak", "dengan", "untuk", "rumah sakit"]
        for word in id_words:
            if word in text.lower():
                return "id"
        return "en"

    def analyze(self, text, country=None):
        language = self.detect_language(text)

        if language == "en":
            return self.analyze_english(text)
        else:
            # For non-English text, translate first then analyze
            translated = self.translate_to_english(text, language)
            result = self.analyze_english(translated)
            result["original_language"] = language
            result["original_text"] = text[:200]
            return result

Reporting and Visualization

Provider Reputation Dashboard

Track key metrics for each healthcare provider:

def generate_provider_report(self, provider_name, reviews):
    provider_reviews = [
        r for r in reviews
        if r.get("provider_name") == provider_name
    ]

    report = {
        "provider": provider_name,
        "total_reviews": len(provider_reviews),
        "average_rating": self.avg([r.get("rating", 0) for r in provider_reviews]),
        "sentiment_distribution": {
            "positive": len([r for r in provider_reviews
                           if r.get("sentiment_class") == "positive"]),
            "neutral": len([r for r in provider_reviews
                          if r.get("sentiment_class") == "neutral"]),
            "negative": len([r for r in provider_reviews
                           if r.get("sentiment_class") == "negative"])
        },
        "aspect_scores": self.aggregate_aspect_scores(provider_reviews),
        "trending_topics": self.extract_trending_topics(provider_reviews),
        "recent_trend": self.calculate_trend(provider_reviews),
        "generated_at": datetime.utcnow().isoformat()
    }

    return report

def aggregate_aspect_scores(self, reviews):
    aspect_totals = {}
    aspect_counts = {}

    for review in reviews:
        aspects = review.get("aspects", {})
        for aspect_name, aspect_data in aspects.items():
            if aspect_data.get("sentiment") is not None:
                if aspect_name not in aspect_totals:
                    aspect_totals[aspect_name] = 0
                    aspect_counts[aspect_name] = 0
                aspect_totals[aspect_name] += aspect_data["sentiment"]
                aspect_counts[aspect_name] += 1

    return {
        name: aspect_totals[name] / aspect_counts[name]
        for name in aspect_totals
    }

Competitive Benchmarking

Compare providers within the same market:

def benchmark_providers(self, providers, country, reviews_db):
    benchmark = []
    for provider in providers:
        reviews = reviews_db.get_reviews(provider, country)
        if reviews:
            analyzed = [self.analyzer.analyze_sentiment(r["text"])
                       for r in reviews]
            benchmark.append({
                "provider": provider,
                "review_count": len(reviews),
                "avg_sentiment": sum(a["final_score"] for a in analyzed)
                                / len(analyzed),
                "positive_pct": len([a for a in analyzed
                                    if a["classification"] == "positive"])
                               / len(analyzed) * 100,
                "top_strengths": self.identify_strengths(analyzed),
                "top_weaknesses": self.identify_weaknesses(analyzed)
            })

    return sorted(benchmark, key=lambda x: x["avg_sentiment"], reverse=True)

Data Collection Schedule

  • Daily: Collect new reviews from Google Maps and major platforms for priority providers
  • Weekly: Full review collection across all monitored providers and platforms
  • Monthly: Comprehensive sentiment analysis reports with trend comparisons

Best Practices

  1. Use mobile proxies for Google Maps: Google heavily restricts automated access. DataResearchTools mobile proxies provide the most reliable access to review data.
  1. Collect reviews in original languages: Do not rely solely on translated reviews. Analyze sentiment in the original language when possible.
  1. Handle fake reviews: Implement detection for suspicious review patterns (bulk positive reviews, templated text, reviewer account analysis).
  1. Respect privacy: Never collect or store personally identifiable patient health information from reviews. Focus on sentiment and themes, not individual patient details.
  1. Track trends over time: Single-point sentiment scores are less valuable than trend analysis. Monitor how sentiment changes in response to service improvements or issues.
  1. Contextualize ratings: A 4.0 rating in one market might indicate different satisfaction levels than in another, due to cultural rating tendencies.

Conclusion

Hospital and clinic review scraping powered by mobile proxies from DataResearchTools enables comprehensive patient sentiment analysis across Southeast Asian healthcare markets. By combining reliable data collection with aspect-based sentiment analysis and competitive benchmarking, healthcare organizations gain the insights needed to improve patient experience and strengthen their market position.

DataResearchTools mobile proxies in every major SEA market ensure your review collection runs smoothly across Google Maps, healthcare platforms, and social media, delivering the patient voice data that drives better healthcare outcomes.

Related Reading

Scroll to Top