Ever wish you could see all your customer reviews—Amazon, Yelp, Google, the works—in one place? If you’re running a business, tracking competitors, or just like to know what people really think, collecting reviews from multiple platforms can be a goldmine. But doing it manually? That’s a time sink most of us can’t afford.
This guide is for folks who want to pull reviews from several sites, make sense of them, and actually use what they learn. We’re using Zenrows, a scraping tool built to deal with the annoying stuff—anti-bot blocks, dynamic pages—so you can focus on the data, not the headaches.
Let’s get you from “where are my reviews?” to “here’s what my customers are actually saying.”
Step 1: Figure Out What You Need (and What You Don’t)
Before you start scraping, get clear on:
- Which platforms matter? Don’t try to grab everything. Amazon, Yelp, and Google are common, but maybe you care about TripAdvisor, Trustpilot, or industry-specific sites instead.
- What data is useful? Just the text? Ratings? Dates? Reviewer locations? Decide now, so you don’t waste time later.
- How often do you need updates? Is this a one-time project, or do you want a regular feed?
Pro tip: Don’t over-engineer. Start with one or two sources. Expand once you’ve got a workflow that doesn’t make you want to pull your hair out.
Step 2: Get to Know Zenrows
Zenrows is a paid web scraping API. You send it a URL, it sends back the HTML—often getting around things that would trip up regular scrapers, like JavaScript rendering or anti-bot measures. You don’t need to install a bunch of libraries or run a headless browser yourself.
Why use Zenrows?
- It handles dynamic sites and CAPTCHAs better than most DIY scripts.
- You get an API key, so you can use it from Python, JavaScript, or even curl.
- They have a free tier, but expect to hit limits if you’re scraping a lot.
What Zenrows won’t do:
- It won’t parse or analyze your data for you. It just grabs the HTML (or JSON, if you’re lucky).
- It can’t magically get around every block. Some sites are still tough, even for them.
Step 3: Find Your Target URLs
For each platform, identify the exact pages you want to scrape. Here’s what to keep in mind:
- Amazon: Product review pages. Watch for pagination—each page only shows a slice.
- Yelp: Your business’s review page or a competitor’s.
- Google: This one’s trickier. The web version mixes in maps and JavaScript, so try to find a stable URL or consider Google Maps API (but it’s not free).
Don’t:
- Don’t try to scrape logged-in or paywalled content unless you really know what you’re doing (and the legal risks).
- Don’t flood sites with requests. Keep it slow, or you’ll get blocked fast.
Step 4: Make Your First Zenrows API Call
Let’s say you want to grab Amazon reviews for a product. Here’s a simple Python example:
python import requests
ZENROWS_API_KEY = "your_api_key_here" url = "https://www.amazon.com/product-reviews/B09G3HRMVB/" api_url = f"https://api.zenrows.com/v1/?apikey={ZENROWS_API_KEY}&url={url}&js_render=true"
response = requests.get(api_url) html = response.text
print(html[:1000]) # Just to see you got something
js_render=true
tells Zenrows to run JavaScript, which you’ll need for many review pages.- Swap in your own API key and target URLs.
What can go wrong?
- Amazon and Yelp change their HTML layouts constantly. Your selectors may break.
- If you request too many pages too quickly, even Zenrows can hit limits or CAPTCHAs.
- Some review sections are loaded dynamically after the initial page load. That’s why
js_render
is critical.
Step 5: Parse the HTML for Review Data
Zenrows gets you the HTML, but now you need to extract the actual reviews. Use something like BeautifulSoup (Python) or Cheerio (JavaScript) to pull out:
- Review text
- Star rating
- Reviewer name (if available)
- Date
Example (Python + BeautifulSoup):
python from bs4 import BeautifulSoup
soup = BeautifulSoup(html, "html.parser") reviews = []
for block in soup.select(".review"): text = block.select_one(".review-text").get_text(strip=True) rating = block.select_one(".review-rating").get_text(strip=True) date = block.select_one(".review-date").get_text(strip=True) reviews.append({ "text": text, "rating": rating, "date": date })
print(reviews[:2])
- The actual selectors (
.review
,.review-text
, etc.) will definitely change based on the site, and sometimes even from week to week. - Plan to adjust your code as sites update their layouts.
Pro tip: Scraping is a moving target. Don’t get too attached to your selectors.
Step 6: Handle Pagination (The Boring, Necessary Part)
Most sites don’t show all reviews on one page. You’ll need to:
- Identify the URL pattern for additional pages (look for
?page=2
or similar in the URL). - Loop through pages, collecting reviews from each.
- Stop when you hit the end—usually when there are no more “next page” links.
Don’t:
- Don’t grab 100 pages in one go if you don’t need them. Start small.
- Don’t ignore the site’s robots.txt or terms of service. You’re responsible for what you scrape.
Step 7: Store Your Data Somewhere Useful
Don’t just print reviews to your terminal—save them:
- CSV files (easy for Excel or Google Sheets)
- SQLite or Postgres (if you want to search/filter)
- A cloud database or Google Sheets, for sharing with a team
Example: Save to CSV (Python):
python import csv
with open("reviews.csv", "w", newline="", encoding="utf-8") as f: writer = csv.DictWriter(f, fieldnames=["text", "rating", "date"]) writer.writeheader() writer.writerows(reviews)
Pro tip:
Save raw HTML for a handful of pages too. If your parser breaks, you won’t have to re-scrape everything to debug.
Step 8: Analyze the Reviews (Without Drowning in Data)
You’ve got a pile of reviews. Now what?
- Look for trends: What words or phrases keep popping up? Python’s
collections.Counter
or a quick word cloud can help. - Average ratings: Calculate simple stats—average, median, range.
- Spot outliers: Are there a few 1-star reviews tanking your average? It’s usually worth reading those closely.
What’s not worth your time (at first):
- Fancy “sentiment analysis” unless you have a lot of data and real business need.
- Overly complicated dashboards.
- Manual tagging—unless you’re only dealing with a few dozen reviews.
Start simple. The goal is insight, not analysis paralysis.
Step 9: Automate (Only If It’s Worth It)
If you find yourself repeating this process every week or month, automate:
- Schedule your scraper to run (e.g., with cron jobs or GitHub Actions).
- Send yourself an email or Slack message with a summary.
- Keep an eye on Zenrows usage and costs.
But:
Don’t build a robot army until you’re sure the data is valuable. Manual is fine for a while.
What to Watch Out For
- Legal gray zones: Scraping isn’t always welcome. Read the terms for each platform. Most won’t let you scrape for commercial purposes.
- Changing HTML: Sites tweak layouts all the time. Expect maintenance.
- API limits: Zenrows has quotas. If you’re scraping a lot, costs add up.
- Data quality: Not all reviews are honest. Don’t take every 5-star (or 1-star) at face value.
Keep It Simple, Iterate Often
Pulling reviews from multiple platforms isn’t rocket science, but it does take patience. Start with one site, get your workflow working, and only then add complexity. Most importantly: Don’t spend weeks building a system before you see if the data actually helps you.
Stick with what works, fix what breaks, and don’t let perfect be the enemy of done. Happy scraping.