Proxy'lerle Büyük Ölçekli Ürün Yorumları Nasıl Scrape Edilir

Ürün değerlendirmeleri neden Scale?

Ürün incelemeleri, e-ticaretteki en değerli veri kaynaklarından biridir. Müşteri duygularını, ürün kalite sorunlarını, özel talepleri ve rekabetçi konumlandırmaları ortaya koyarlar - başka bir veri kaynağının sağlanamayacağı bilgiler. Ölçekte, inceleme verileri sağlar:

• Sentiment analizi: Müşteriler ürün ve rakiplerinizin ürünlerini zamanla nasıl hissederler.
• Ürün gelişimi: Tekrarlanan şikayetleri tanımlayın ve binlerce inceleme boyunca özel istekler.
• Rekabetçi zeka: Rakip güçlerini ve zayıflıklarını müşterilerinin kendi sözleriyle anlayın.
• Pazar araştırması: Listedeki inceleme modellerini analiz ederek ihtiyaç ve ortaya çıkan eğilimleri keşfedin.
• Kalite izleme: Ürün kalitesi sorunları erken inceleme duygu eğilimlerini tespit ederek.

Sorun şu ki, inceleme verileri birden fazla platformda yayılıyor (Amazon, Walmart, En İyi Satın, Güvenpilot, Google), her biri farklı yapılar ve anti-bot korumaları ile. Ölçekte incelemeler platformun özel stratejileri ve sağlam proxy altyapısı gerektirir. Temel e-ticaret kazı modelleri için, bizi gör e-ticaret verileri kılavuzluk.

Data Structure Across Platforms

İnceleme için Proxy Yapılandırma

Yeniden kazılama, paginated navigasyon içerir, bu da seansları birden fazla istekle korumak anlamına gelir. ProxyHat'ın yapışkan seansları bu model için idealdir.

ProxyHat Build

# Per-request rotation for initial product lookups
http://USERNAME:PASSWORD@gate.proxyhat.com:8080
# Sticky session for paginating through reviews of one product
http://USERNAME-session-rev001:PASSWORD@gate.proxyhat.com:8080
# Geo-targeted for region-specific review pages
http://USERNAME-country-US:PASSWORD@gate.proxyhat.com:8080

Yeniden kazıma için, tek bir ürün için tüm incelemeler yoluyla bayıl seansları kullanın ve farklı ürünler arasında hareket ederken per-request rotasyonu kullanın. Bu mimiks doğal tarama davranışı, bir kullanıcının bir sonrakiye taşınmadan önce bir ürün için birden fazla inceleme okuduğu.

Python Uygulaması

İşte çok platformlu bir inceleme trer kullanımı ProxyHat's Python SDK.

Amazon Review Boater

import requests
from bs4 import BeautifulSoup
import json
import time
import random
from dataclasses import dataclass
from datetime import datetime
PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
]
@dataclass
class Review:
    platform: str
    product_id: str
    rating: float
    title: str
    text: str
    date: str
    author: str
    verified: bool
    helpful_votes: int
def scrape_amazon_reviews(asin, max_pages=10):
    """Scrape all reviews for an Amazon product."""
    reviews = []
    session_id = f"rev-{asin}-{random.randint(1000, 9999)}"
    proxy = f"http://USERNAME-session-{session_id}:PASSWORD@gate.proxyhat.com:8080"
    session = requests.Session()
    session.proxies = {"http": proxy, "https": proxy}
    session.headers.update({
        "User-Agent": random.choice(USER_AGENTS),
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
    })
    for page in range(1, max_pages + 1):
        url = (f"https://www.amazon.com/product-reviews/{asin}"
               f"?pageNumber={page}&sortBy=recent")
        try:
            response = session.get(url, timeout=30)
            if response.status_code != 200:
                break
            if "captcha" in response.text.lower():
                print(f"CAPTCHA on page {page}, switching session")
                break
            soup = BeautifulSoup(response.text, "html.parser")
            review_divs = soup.find_all("div", {"data-hook": "review"})
            if not review_divs:
                break
            for div in review_divs:
                review = parse_amazon_review(div, asin)
                if review:
                    reviews.append(review)
            print(f"Page {page}: {len(review_divs)} reviews (total: {len(reviews)})")
            time.sleep(random.uniform(2, 5))
        except requests.RequestException as e:
            print(f"Error on page {page}: {e}")
            break
    return reviews
def parse_amazon_review(div, asin):
    """Parse a single Amazon review element."""
    try:
        rating_el = div.find("i", {"data-hook": "review-star-rating"})
        rating = float(rating_el.get_text().split(" ")[0]) if rating_el else None
        title_el = div.find("a", {"data-hook": "review-title"})
        title = title_el.get_text(strip=True) if title_el else ""
        body_el = div.find("span", {"data-hook": "review-body"})
        text = body_el.get_text(strip=True) if body_el else ""
        date_el = div.find("span", {"data-hook": "review-date"})
        date_str = date_el.get_text(strip=True) if date_el else ""
        author_el = div.find("span", {"class": "a-profile-name"})
        author = author_el.get_text(strip=True) if author_el else ""
        verified = bool(div.find("span", {"data-hook": "avp-badge"}))
        helpful_el = div.find("span", {"data-hook": "helpful-vote-statement"})
        helpful = 0
        if helpful_el:
            text_h = helpful_el.get_text()
            if "one" in text_h.lower():
                helpful = 1
            else:
                nums = [int(s) for s in text_h.split() if s.isdigit()]
                helpful = nums[0] if nums else 0
        return Review(
            platform="amazon",
            product_id=asin,
            rating=rating,
            title=title,
            text=text,
            date=date_str,
            author=author,
            verified=verified,
            helpful_votes=helpful,
        )
    except Exception:
        return None

Multi-Platform Review Jewel

class ReviewCollector:
    """Collect reviews from multiple platforms for a product."""
    def __init__(self):
        self.scrapers = {
            "amazon": scrape_amazon_reviews,
        }
    def collect_all(self, product_ids: dict) -> list[Review]:
        """
        Collect reviews from all platforms.
        product_ids: {"amazon": "B0CHX3QBCH", "walmart": "12345"}
        """
        all_reviews = []
        for platform, product_id in product_ids.items():
            if platform in self.scrapers:
                print(f"\nScraping {platform} reviews for {product_id}")
                reviews = self.scrapers[platform](product_id)
                all_reviews.extend(reviews)
                print(f"Collected {len(reviews)} reviews from {platform}")
                time.sleep(random.uniform(5, 10))
        return all_reviews
    def to_dataframe(self, reviews: list[Review]):
        """Convert reviews to a pandas DataFrame for analysis."""
        import pandas as pd
        return pd.DataFrame([vars(r) for r in reviews])
# Usage
collector = ReviewCollector()
reviews = collector.collect_all({
    "amazon": "B0CHX3QBCH",
})
print(f"\nTotal reviews collected: {len(reviews)}")

Node.js Uygulama

A Node.js review scraper using ProxyHat's Node SDK.

const axios = require("axios");
const cheerio = require("cheerio");
const { HttpsProxyAgent } = require("https-proxy-agent");
function getProxy(sessionId = null) {
  if (sessionId) {
    return `http://USERNAME-session-${sessionId}:PASSWORD@gate.proxyhat.com:8080`;
  }
  return "http://USERNAME:PASSWORD@gate.proxyhat.com:8080";
}
async function scrapeAmazonReviews(asin, maxPages = 10) {
  const reviews = [];
  const sessionId = `rev-${asin}-${Math.floor(Math.random() * 9000 + 1000)}`;
  const agent = new HttpsProxyAgent(getProxy(sessionId));
  for (let page = 1; page <= maxPages; page++) {
    const url = `https://www.amazon.com/product-reviews/${asin}?pageNumber=${page}&sortBy=recent`;
    try {
      const { data } = await axios.get(url, {
        httpsAgent: agent,
        headers: {
          "User-Agent":
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36",
          "Accept-Language": "en-US,en;q=0.9",
        },
        timeout: 30000,
      });
      if (data.toLowerCase().includes("captcha")) {
        console.log(`CAPTCHA on page ${page}`);
        break;
      }
      const $ = cheerio.load(data);
      const reviewDivs = $('[data-hook="review"]');
      if (reviewDivs.length === 0) break;
      reviewDivs.each((_, el) => {
        const $el = $(el);
        const ratingText = $el.find('[data-hook="review-star-rating"]').text();
        const rating = parseFloat(ratingText.split(" ")[0]) || null;
        reviews.push({
          platform: "amazon",
          productId: asin,
          rating,
          title: $el.find('[data-hook="review-title"]').text().trim(),
          text: $el.find('[data-hook="review-body"]').text().trim(),
          date: $el.find('[data-hook="review-date"]').text().trim(),
          author: $el.find(".a-profile-name").text().trim(),
          verified: $el.find('[data-hook="avp-badge"]').length > 0,
        });
      });
      console.log(`Page ${page}: ${reviewDivs.length} reviews (total: ${reviews.length})`);
      await new Promise((r) => setTimeout(r, 2000 + Math.random() * 3000));
    } catch (err) {
      console.error(`Error page ${page}: ${err.message}`);
      break;
    }
  }
  return reviews;
}
// Usage
scrapeAmazonReviews("B0CHX3QBCH", 5).then((reviews) => {
  console.log(`Collected ${reviews.length} reviews`);
  console.log(JSON.stringify(reviews.slice(0, 2), null, 2));
});

Pagination at Scale

İnceleme paginasyon, büyük ölçekli inceleme kazılarında en büyük zorluklardan biridir.

Amazon Pagination Strategy

Amazon, her biri için 10 inceleme sayfasını ve genellikle 500 sayfaya (5.000 yorum) gösterir. Daha fazla inceleme ile ürünler için filtre parametrelerini segmente kullanın:

# Filter by star rating to get more reviews
star_filters = [
    "one_star", "two_star", "three_star",
    "four_star", "five_star"
]
for star in star_filters:
    url = (f"https://www.amazon.com/product-reviews/{asin}"
           f"?filterByStar={star}&pageNumber={page}")
    # This lets you access more reviews per product

Pagination için Oturum Yönetimi

Her ürünün incelemesi paginasyon kendi yapışkan seansını kullanmalıdır. Bir ürünü bitirdiğinizde ve bir sonrakiye taşınırken, farklı bir IP ile yeni bir oturum oluşturun.

Sentiment Analysis için veri hazırlamak

Raw inceleme metni, duygusal analizden önce işlemeye ihtiyaç duyar.

import re
from collections import Counter
def clean_review_text(text):
    """Clean review text for analysis."""
    # Remove HTML entities
    text = re.sub(r'&\w+;', ' ', text)
    # Remove excessive whitespace
    text = re.sub(r'\s+', ' ', text).strip()
    # Remove very short reviews (likely not useful)
    if len(text) < 20:
        return None
    return text
def extract_key_phrases(reviews, min_frequency=3):
    """Extract frequently mentioned phrases from reviews."""
    from collections import Counter
    import re
    words = []
    for review in reviews:
        if review.text:
            # Simple bigram extraction
            tokens = re.findall(r'\b\w+\b', review.text.lower())
            for i in range(len(tokens) - 1):
                bigram = f"{tokens[i]} {tokens[i+1]}"
                words.append(bigram)
    return Counter(words).most_common(50)
def aggregate_sentiment(reviews):
    """Calculate aggregate sentiment metrics."""
    if not reviews:
        return {}
    ratings = [r.rating for r in reviews if r.rating]
    return {
        "total_reviews": len(reviews),
        "avg_rating": sum(ratings) / len(ratings) if ratings else 0,
        "rating_distribution": {
            str(i): len([r for r in reviews if r.rating == i])
            for i in range(1, 6)
        },
        "verified_pct": (
            len([r for r in reviews if r.verified]) / len(reviews) * 100
            if reviews else 0
        ),
    }

Milyonlarca İncelemeye Giriş

Hedef listeniz birden fazla platformda binlerce ürün büyüdüğünde mimarlık önemlidir.

Queue-Based Architecture

• Ürün listesini yönetmek ve işçilerle iş dağıtmak için bir mesaj kuyruğu (Redis, TavşanMQ) kullanın.
• Her işçi bir anda tek bir ürünle çalışır: tüm incelemeler, mağaza sonuçları aracılığıyla, bir sonraki ürüne taşınır.
• Farklı oran sınırlarına saygı göstermek için platformda ayrı kuyruklar.

Depolama Stratejisi

• nesne depolamasında ham HTML (S3) .s değiştiğinde yeniden işleme için.
• Store, analiz için tam metin arama ile PostgreSQL'de gözden geçirildi.
• İnceleme ID'ye dayanan veya tekrar-scrapes'ta tekrar çoğaltmaktan kaçınmak için çoğaltma kullanın.

Kulluk

Devamlı izleme için, her seferinde tüm yorumları yeniden değerlendirmeniz gerekmez. En son gelene göre sıralayın ve zaten topladığınız bir inceleme vurduğunuzda durun. Bu, proxy kullanımını ve koleksiyonlarını dramatik bir şekilde azaltır.

Key takeaway: Daha önce toplanan içeriği çarptığında en yeni ilk ve kazımayı durdurun. Bu, artımlı bir güncellemeye tam bir re-scrape döndürür.

En İyi Uygulamaları

• paginasyon için yapışkan seanslar kullanın: Aynı IP'yi, anti-bot algılamasını önlemek için tek bir ürün için gözden geçirmek.
• Saygı oranı sınırları: Sayfalar arasında 2-5 ikinci gecikme, ürünler arasında daha uzun gecikmeler. Farklı platformlar farklı toleranslara sahiptir.
• Boş sayfaları tut: Boş bir inceleme sayfası, sonuna ulaştığınız anlamına gelir. Daha fazla sayfa denemeye devam etmeyin.
• Geçerli veri kalitesi: CAPTCHA sayfaları, boş içerik ve boru hattınızda tekrarlanan yorumları kontrol edin.
• Use Use Use Use Use Use Konut sahipleri: Amazon ve diğer ağır koruma platformları için temel.
• Mağaza artışı: Süreç ve mağaza incelemeleri onları kazırken, sonunda bir partide değil.

Key Takeaways

• İnceleme verileri diğer veri kaynağının sunduğu eşsiz rekabetçi zeka sağlar.
• Farklı platformlar farklı kazı stratejileri gerektirir - platformda modüler hurdalar inşa edin.
• Pigination ve per-request rotasyonu ürünleri arasında incelemek için yapışkan seanslar kullanın.
• En yeni ilk olarak sıralayın ve daha önce verimli arter boya için değerlendirmeleri durdurun.
• Preprocess review text for sense analysis: Temiz, deduplicate, ve anahtar cümleleri çıkarın.
• Use Use Use Use Use Use ProxyHat'ın konut temsilcileri Tüm platformlardaki sayfaları incelemeye güvenilir erişim için geo-targeting ile.

İnceleme verileri toplamaya başlamak için hazır mı? Görmemize bakın Amazon kılavuzluk rehberi Platforma özel detaylar ve bizim e-ticaret verileri kılavuzluk Tam strateji için. Check Check Check Check Python'daki referansları ve Node.js'deki referansları Uygulama kalıpları için.