Introduction

Amazon product reviews provide valuable insights into customer sentiment, product quality, and user experience. This tutorial shows you how to scrape review data for sentiment analysis, competitive research, and customer feedback monitoring.

What You'll Extract

Reviewer names & profiles

Star ratings (1-5)

Review title & text

Review dates

Verified purchase status

Helpful vote counts

Prerequisites

Make sure you have your API key ready. You can get one from the dashboard.

2

Quick Start

Get up and running in minutes with our streamlined setup process.

Installation

Terminal

pip install requests
# or for Node.js
npm install axios

Basic Request

curl -X POST "https://api.ujeebu.com/scrape" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://www.amazon.com/product-reviews/B08N5WRWNW/","js":true,"wait_for":"[data-hook=review]","extract_rules":{"reviews":{"selector":"[data-hook=review]","type":"obj","multiple":true,"children":{"reviewer_name":{"selector":".a-profile-name","type":"text"},"rating":{"selector":"i[data-hook=review-star-rating] span","type":"text"},"title":{"selector":"a[data-hook=review-title] span","type":"text"},"date":{"selector":"span[data-hook=review-date]","type":"text"},"review_text":{"selector":"span[data-hook=review-body] span","type":"text"}}}}}'

import requests

extract_rules = {
    "reviews": {
        "selector": "[data-hook=review]",
        "type": "obj",
        "multiple": True,
        "children": {
            "reviewer_name": {"selector": ".a-profile-name", "type": "text"},
            "rating": {"selector": "i[data-hook=review-star-rating] span", "type": "text"},
            "title": {"selector": "a[data-hook=review-title] span", "type": "text"},
            "date": {"selector": "span[data-hook=review-date]", "type": "text"},
            "review_text": {"selector": "span[data-hook=review-body] span", "type": "text"}
        }
    }
}

response = requests.post("https://api.ujeebu.com/scrape",
    headers={
        "ApiKey": "YOUR_API_KEY",
        "Content-Type": "application/json"
    },
    json={
        "url": "https://www.amazon.com/product-reviews/B08N5WRWNW/",
        "js": True,
        "wait_for": "[data-hook=review]",
        "extract_rules": extract_rules
    })

reviews = response.json()["result"]["reviews"]
print(f"Scraped {len(reviews)} reviews")
for review in reviews:
    print(f"{review.get('rating')} - {review.get('title')}")

const axios = require('axios');

const extractRules = {
  reviews: {
    selector: '[data-hook=review]',
    type: 'obj',
    multiple: true,
    children: {
      reviewer_name: { selector: '.a-profile-name', type: 'text' },
      rating: { selector: 'i[data-hook=review-star-rating] span', type: 'text' },
      title: { selector: 'a[data-hook=review-title] span', type: 'text' },
      date: { selector: 'span[data-hook=review-date]', type: 'text' },
      review_text: { selector: 'span[data-hook=review-body] span', type: 'text' }
    }
  }
};

(async () => {
  const response = await axios.post('https://api.ujeebu.com/scrape', {
    url: 'https://www.amazon.com/product-reviews/B08N5WRWNW/',
    js: true,
    wait_for: '[data-hook=review]',
    extract_rules: extractRules
  }, {
    headers: { 'ApiKey': 'YOUR_API_KEY', 'Content-Type': 'application/json' }
  });

  const reviews = response.data.result.reviews;
  console.log(`Scraped ${reviews.length} reviews`);
  for (const review of reviews) {
    console.log(`${review.rating} - ${review.title}`);
  }
})();

from ujeebu_python import UjeebuClient

uj = UjeebuClient(api_key="YOUR_API_KEY")

extract_rules = {
    "reviews": {
        "selector": "[data-hook=review]",
        "type": "obj",
        "multiple": True,
        "children": {
            "reviewer_name": {"selector": ".a-profile-name", "type": "text"},
            "rating": {"selector": "i[data-hook=review-star-rating] span", "type": "text"},
            "title": {"selector": "a[data-hook=review-title] span", "type": "text"},
            "date": {"selector": "span[data-hook=review-date]", "type": "text"},
            "review_text": {"selector": "span[data-hook=review-body] span", "type": "text"}
        }
    }
}

res = uj.scrape_with_rules(
    "https://www.amazon.com/product-reviews/B08N5WRWNW/",
    extract_rules=extract_rules,
    params={"js": True, "wait_for": "[data-hook=review]"})

reviews = res.json()["result"]["reviews"]
print(f"Scraped {len(reviews)} reviews")
for review in reviews:
    print(f"{review.get('rating')} - {review.get('title')}")

const { UjeebuClient } = require('@ujeebu-org/ujeebu-sdk');

const client = new UjeebuClient("YOUR_API_KEY");

const extractRules = {
  reviews: {
    selector: '[data-hook=review]',
    type: 'obj',
    multiple: true,
    children: {
      reviewer_name: { selector: '.a-profile-name', type: 'text' },
      rating: { selector: 'i[data-hook=review-star-rating] span', type: 'text' },
      title: { selector: 'a[data-hook=review-title] span', type: 'text' },
      date: { selector: 'span[data-hook=review-date]', type: 'text' },
      review_text: { selector: 'span[data-hook=review-body] span', type: 'text' }
    }
  }
};

(async () => {
  const res = await client.scrape('https://www.amazon.com/product-reviews/B08N5WRWNW/', {
    js: true,
    wait_for: '[data-hook=review]',
    extract_rules: extractRules
  });

  const reviews = res.data.result.reviews;
  console.log(`Scraped ${reviews.length} reviews`);
  for (const review of reviews) {
    console.log(`${review.rating} - ${review.title}`);
  }
})();

<?php
$extractRules = [
    'reviews' => [
        'selector' => '[data-hook=review]',
        'type' => 'obj',
        'multiple' => true,
        'children' => [
            'reviewer_name' => ['selector' => '.a-profile-name', 'type' => 'text'],
            'rating' => ['selector' => 'i[data-hook=review-star-rating] span', 'type' => 'text'],
            'title' => ['selector' => 'a[data-hook=review-title] span', 'type' => 'text'],
            'date' => ['selector' => 'span[data-hook=review-date]', 'type' => 'text'],
            'review_text' => ['selector' => 'span[data-hook=review-body] span', 'type' => 'text'],
        ],
    ],
];

$ch = curl_init();
curl_setopt_array($ch, [
    CURLOPT_URL => 'https://api.ujeebu.com/scrape',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => ['ApiKey: YOUR_API_KEY', 'Content-Type: application/json'],
    CURLOPT_POSTFIELDS => json_encode([
        'url' => 'https://www.amazon.com/product-reviews/B08N5WRWNW/',
        'js' => true,
        'wait_for' => '[data-hook=review]',
        'extract_rules' => $extractRules,
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$reviews = json_decode($response, true)['result']['reviews'] ?? [];
echo "Scraped " . count($reviews) . " reviews\n";
foreach ($reviews as $review) {
    echo "{$review['rating']} - {$review['title']}\n";
}

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func main() {
	rules := map[string]any{
		"reviews": map[string]any{
			"selector": "[data-hook=review]",
			"type":     "obj",
			"multiple": true,
			"children": map[string]any{
				"reviewer_name": map[string]any{"selector": ".a-profile-name", "type": "text"},
				"rating":        map[string]any{"selector": "i[data-hook=review-star-rating] span", "type": "text"},
				"title":         map[string]any{"selector": "a[data-hook=review-title] span", "type": "text"},
				"date":          map[string]any{"selector": "span[data-hook=review-date]", "type": "text"},
				"review_text":   map[string]any{"selector": "span[data-hook=review-body] span", "type": "text"},
			},
		},
	}
	payload, _ := json.Marshal(map[string]any{
		"url":           "https://www.amazon.com/product-reviews/B08N5WRWNW/",
		"js":            true,
		"wait_for":      "[data-hook=review]",
		"extract_rules": rules,
	})
	req, _ := http.NewRequest("POST", "https://api.ujeebu.com/scrape", bytes.NewReader(payload))
	req.Header.Set("ApiKey", "YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	body, _ := io.ReadAll(res.Body)
	res.Body.Close()

	var parsed struct {
		Result struct {
			Reviews []struct {
				ReviewerName string `json:"reviewer_name"`
				Rating       string `json:"rating"`
				Title        string `json:"title"`
				Date         string `json:"date"`
				ReviewText   string `json:"review_text"`
			} `json:"reviews"`
		} `json:"result"`
	}
	json.Unmarshal(body, &parsed)

	fmt.Printf("Scraped %d reviews\n", len(parsed.Result.Reviews))
	for _, review := range parsed.Result.Reviews {
		fmt.Printf("%s - %s\n", review.Rating, review.Title)
	}
}

package main

import (
	"encoding/json"
	"fmt"
	"log"

	"github.com/ujeebu/ujeebu-go"
)

func main() {
	client, err := ujeebu.NewClient("YOUR_API_KEY")
	if err != nil {
		log.Fatal(err)
	}

	rules := map[string]any{
		"reviews": map[string]any{
			"selector": "[data-hook=review]",
			"type":     "obj",
			"multiple": true,
			"children": map[string]any{
				"reviewer_name": map[string]any{"selector": ".a-profile-name", "type": "text"},
				"rating":        map[string]any{"selector": "i[data-hook=review-star-rating] span", "type": "text"},
				"title":         map[string]any{"selector": "a[data-hook=review-title] span", "type": "text"},
				"date":          map[string]any{"selector": "span[data-hook=review-date]", "type": "text"},
				"review_text":   map[string]any{"selector": "span[data-hook=review-body] span", "type": "text"},
			},
		},
	}

	resp, _, err := client.Scrape(ujeebu.ScrapeParams{
		URL:          "https://www.amazon.com/product-reviews/B08N5WRWNW/",
		JS:           true,
		WaitFor:      "[data-hook=review]",
		ExtractRules: rules,
	})
	if err != nil {
		log.Fatal(err)
	}

	var data struct {
		Reviews []struct {
			ReviewerName string `json:"reviewer_name"`
			Rating       string `json:"rating"`
			Title        string `json:"title"`
			Date         string `json:"date"`
			ReviewText   string `json:"review_text"`
		} `json:"reviews"`
	}
	b, _ := json.Marshal(resp.Result)
	json.Unmarshal(b, &data)

	fmt.Printf("Scraped %d reviews\n", len(data.Reviews))
	for _, review := range data.Reviews {
		fmt.Printf("%s - %s\n", review.Rating, review.Title)
	}
}

3

Core Features

Lightning Fast - Optimized performance with automatic JavaScript rendering

Reliable - Full JSON schema support for consistent data

Modern Syntax - Clean CSS selectors with nested extraction

Great DX - Comprehensive error messages and debugging

4

Extract Rules Configuration

Customize your extraction by defining the data structure you need.

CSS Selectors Reference

Data Point	CSS Selector	Type
Review Container	`[data-hook="review"]`	obj
Reviewer Name	`.a-profile-name`	text
Rating	`i[data-hook="review-star-rating"]`	attr
Review Title	`a[data-hook="review-title"]`	text
Review Date	`span[data-hook="review-date"]`	text
Verified Purchase	`span[data-hook="avp-badge"]`	text
Review Text	`span[data-hook="review-body"]`	text

Changes to extract rules require testing with real pages to ensure selectors are accurate.

Complete Extract Rules

JSON - Extract Rules

{
  "reviews": {
    "selector": "[data-hook='review']",
    "type": "obj",
    "multiple": true,
    "children": {
      "reviewer_name": {"selector": ".a-profile-name", "type": "text"},
      "rating": {"selector": "i[data-hook='review-star-rating'] span", "type": "text"},
      "title": {"selector": "a[data-hook='review-title'] span", "type": "text"},
      "date": {"selector": "span[data-hook='review-date']", "type": "text"},
      "verified_purchase": {"selector": "span[data-hook='avp-badge']", "type": "text"},
      "review_text": {"selector": "span[data-hook='review-body'] span", "type": "text"},
      "helpful_count": {"selector": "span[data-hook='helpful-vote-statement']", "type": "text"}
    }
  },
  "average_rating": {"selector": "i[data-hook='average-star-rating'] span", "type": "text"},
  "total_ratings": {"selector": "span[data-hook='total-review-count']", "type": "text"}
}

5

API Examples

Create backend endpoints easily with API routes in your application.

import requests
import json
import time

extract_rules = {
    "reviews": {
        "selector": "[data-hook='review']",
        "type": "obj",
        "multiple": True,
        "children": {
            "reviewer_name": {"selector": ".a-profile-name", "type": "text"},
            "rating": {"selector": "i[data-hook='review-star-rating'] span", "type": "text"},
            "title": {"selector": "a[data-hook='review-title'] span", "type": "text"},
            "review_text": {"selector": "span[data-hook='review-body'] span", "type": "text"}
        }
    }
}

def scrape_amazon_reviews(product_asin, page=1):
    review_url = f"https://www.amazon.com/product-reviews/{product_asin}/"
    if page > 1:
        review_url += f"?pageNumber={page}"

    response = requests.post("https://api.ujeebu.com/scrape",
        headers={
            "ApiKey": "YOUR_API_KEY",
            "Content-Type": "application/json"
        },
        json={
            "url": review_url,
            "js": True,
            "wait_for": "[data-hook='review']",
            "extract_rules": extract_rules
        })
    return response.json()["result"]

# Scrape multiple pages
all_reviews = []
for page in range(1, 6):
    data = scrape_amazon_reviews("B08N5WRWNW", page)
    all_reviews.extend(data.get("reviews", []))
    time.sleep(2)  # Rate limiting

print(f"Scraped {len(all_reviews)} reviews")

const axios = require('axios');

const extractRules = {
  reviews: {
    selector: "[data-hook='review']",
    type: 'obj',
    multiple: true,
    children: {
      reviewer_name: { selector: '.a-profile-name', type: 'text' },
      rating: { selector: "i[data-hook='review-star-rating'] span", type: 'text' },
      title: { selector: "a[data-hook='review-title'] span", type: 'text' },
      review_text: { selector: "span[data-hook='review-body'] span", type: 'text' }
    }
  }
};

async function scrapeReviews(productAsin, maxPages = 5) {
  const allReviews = [];

  for (let page = 1; page <= maxPages; page++) {
    const url = `https://www.amazon.com/product-reviews/${productAsin}/` +
                (page > 1 ? `?pageNumber=${page}` : '');

    const response = await axios.post('https://api.ujeebu.com/scrape', {
      url,
      js: true,
      wait_for: "[data-hook='review']",
      extract_rules: extractRules
    }, {
      headers: {
        'ApiKey': 'YOUR_API_KEY',
        'Content-Type': 'application/json'
      }
    });

    const reviews = response.data.result.reviews || [];
    allReviews.push(...reviews);

    if (page < maxPages) await new Promise(r => setTimeout(r, 2000));
  }

  return allReviews;
}

// Usage
scrapeReviews('B08N5WRWNW', 5)
  .then(reviews => console.log(`Found ${reviews.length} reviews`));

curl -X POST "https://api.ujeebu.com/scrape" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://www.amazon.com/product-reviews/B08N5WRWNW/",
    "js": true,
    "wait_for": "[data-hook=review]",
    "extract_rules": {
      "reviews": {
        "selector": "[data-hook=review]",
        "type": "obj",
        "multiple": true,
        "children": {
          "reviewer_name": {"selector": ".a-profile-name", "type": "text"},
          "rating": {"selector": "i[data-hook=review-star-rating] span", "type": "text"},
          "title": {"selector": "a[data-hook=review-title] span", "type": "text"},
          "review_text": {"selector": "span[data-hook=review-body] span", "type": "text"}
        }
      }
    }
  }'

from ujeebu_python import UjeebuClient

# Initialize the client
ujeebu = UjeebuClient(api_key="YOUR_API_KEY")

# Define extraction rules
extract_rules = {
    "reviews": {
        "selector": "[data-hook='review']",
        "type": "obj",
        "multiple": True,
        "children": {
            "reviewer_name": {"selector": ".a-profile-name", "type": "text"},
            "rating": {"selector": "i[data-hook='review-star-rating'] span", "type": "text"},
            "title": {"selector": "a[data-hook='review-title'] span", "type": "text"},
            "review_text": {"selector": "span[data-hook='review-body'] span", "type": "text"}
        }
    }
}

# Scrape multiple pages of reviews
def scrape_amazon_reviews(product_asin, page=1):
    review_url = f"https://www.amazon.com/product-reviews/{product_asin}/"
    if page > 1:
        review_url += f"?pageNumber={page}"

    response = ujeebu.scrape_with_rules(
        url=review_url,
        extract_rules=extract_rules,
        params={
            "js": True,
            "wait_for": "[data-hook='review']"
        }
    )
    return response.json()['result']

# Scrape multiple pages
all_reviews = []
for page in range(1, 6):
    data = scrape_amazon_reviews("B08N5WRWNW", page)
    all_reviews.extend(data.get("reviews", []))

print(f"Scraped {len(all_reviews)} reviews")

const { UjeebuClient } = require('@ujeebu-org/ujeebu-sdk');

const client = new UjeebuClient("YOUR_API_KEY");

(async () => {
  const res = await client.scrape("https://www.amazon.com/product-reviews/B08N5WRWNW/", {
  "js": true,
  "wait_for": "[data-hook=review]",
  "extract_rules": {"reviews":{"selector":"[data-hook=review]","type":"obj","multiple":true,"children":{"reviewer_name":{"selector":".a-profile-name","type":"text"},"rating":{"selector":"i[data-hook=review-star-rating] span","type":"text"},"title":{"selector":"a[data-hook=review-title] span","type":"text"},"review_text":{"selector":"span[data-hook=review-body] span","type":"text"}}}},
});
  console.log(res.data);
})();

package main

import (
    "fmt"
    "log"
    "time"
    "github.com/ujeebu/ujeebu-go"
)

func main() {
    // Initialize the client
    client, err := ujeebu.NewClient("YOUR-API-KEY")
    if err != nil {
        log.Fatalf("Failed to create client: %v", err)
    }

    // Define extraction rules
    extractRules := map[string]any{
        "reviews": map[string]any{
            "selector": "[data-hook='review']",
            "type":     "obj",
            "multiple": true,
            "children": map[string]any{
                "reviewer_name": map[string]any{
                    "selector": ".a-profile-name",
                    "type":     "text",
                },
                "rating": map[string]any{
                    "selector": "i[data-hook='review-star-rating'] span",
                    "type":     "text",
                },
                "title": map[string]any{
                    "selector": "a[data-hook='review-title'] span",
                    "type":     "text",
                },
                "review_text": map[string]any{
                    "selector": "span[data-hook='review-body'] span",
                    "type":     "text",
                },
            },
        },
    }

    // Scrape multiple pages
    allReviews := []map[string]any{}
    for page := 1; page <= 5; page++ {
        url := fmt.Sprintf("https://www.amazon.com/product-reviews/B08N5WRWNW/?pageNumber=%d", page)

        params := ujeebu.ScrapeParams{
            URL:          url,
            Js:           true,
            WaitFor:      "[data-hook='review']",
            ExtractRules: extractRules,
        }

        response, _, err := client.Scrape(params)
        if err != nil {
            log.Printf("Error scraping page %d: %v", page, err)
            continue
        }

        if reviews, ok := response["reviews"].([]any); ok {
            for _, review := range reviews {
                if r, ok := review.(map[string]any); ok {
                    allReviews = append(allReviews, r)
                }
            }
        }

        time.Sleep(2 * time.Second) // Rate limiting
    }

    fmt.Printf("Scraped %d reviews\n", len(allReviews))
}

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.ujeebu.com/scrape');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'ApiKey: ' . 'YOUR_API_KEY',
    'Content-Type: application/json',
]);
$payload = [
    'url' => 'https://www.amazon.com/product-reviews/B08N5WRWNW/',
    'js' => true,
    'wait_for' => '[data-hook=review]',
    'extract_rules' => [
        'reviews' => [
            'selector' => '[data-hook=review]',
            'type' => 'obj',
            'multiple' => true,
            'children' => [
                'reviewer_name' => [
                    'selector' => '.a-profile-name',
                    'type' => 'text'
                ],
                'rating' => [
                    'selector' => 'i[data-hook=review-star-rating] span',
                    'type' => 'text'
                ],
                'title' => [
                    'selector' => 'a[data-hook=review-title] span',
                    'type' => 'text'
                ],
                'review_text' => [
                    'selector' => 'span[data-hook=review-body] span',
                    'type' => 'text'
                ]
            ]
        ]
    ]
];
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
$response = curl_exec($ch);
curl_close($ch);
echo $response;

package main

import (
    "fmt"
    "io"
    "strings"
    "net/http"
)

func main() {
    url := "https://api.ujeebu.com/scrape"
    payload := strings.NewReader(`{"url":"https://www.amazon.com/product-reviews/B08N5WRWNW/","js":true,"wait_for":"[data-hook=review]","extract_rules":{"reviews":{"selector":"[data-hook=review]","type":"obj","multiple":true,"children":{"reviewer_name":{"selector":".a-profile-name","type":"text"},"rating":{"selector":"i[data-hook=review-star-rating] span","type":"text"},"title":{"selector":"a[data-hook=review-title] span","type":"text"},"review_text":{"selector":"span[data-hook=review-body] span","type":"text"}}}}}`)
    req, _ := http.NewRequest("POST", url, payload)
    req.Header.Set("ApiKey", "YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")
    res, err := http.DefaultClient.Do(req)
    if err != nil { panic(err) }
    defer res.Body.Close()
    body, _ := io.ReadAll(res.Body)
    fmt.Println(string(body))
}

Pro Tip

Use rotating proxies for bulk scraping to avoid rate limits. Add proxy_type: "rotating" to your params.

6

Best Practices

01

Use Rate Limiting

Always implement delays between requests (2-3 seconds minimum) to avoid overwhelming servers and getting blocked.

Essential

02

Enable Rotating Proxies

For bulk scraping, use proxy_type: "rotating" to distribute requests across multiple IP addresses.

Production

03

Handle Missing Data

Not all reviews have images or verified badges. Use .get() method to safely access optional fields.

Recommended

04

Validate Response

Always check for API errors and validate the structure of extracted data before processing.

Best Practice

Legal Notice

Review Amazon's Terms of Service and robots.txt before scraping. Use scraped data responsibly and in compliance with applicable laws. This tutorial is for educational purposes only.

Scraping Amazon Reviews