# Etsy Reviews Scraper With Sentiment & Analytics (`scraper-engine/etsy-reviews-scraper`) Actor

Extract customer feedback from Etsy listings using the Etsy Reviews Scraper. Collect review text, ratings, reviewer names, dates, and product details automatically. Ideal for product research, sentiment analysis, and eCommerce market insights.

- **URL**: https://apify.com/scraper-engine/etsy-reviews-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### Etsy Reviews Scraper — Ratings, Sentiment & Shop Analytics

Etsy Reviews Scraper With Sentiment & Analytics pulls every public review from one or more Etsy shops — buyer name, star rating, review text, seller response, and the reviewed listing's title and photos — into structured JSON. It can also classify each review's sentiment, topics, language, and spam likelihood with an AI model, and roll up shop-level analytics like rating distribution and response rate. No Etsy account or login is needed. Run it and download results as JSON or CSV.

### 🛍️ What is Etsy Reviews Scraper With Sentiment & Analytics?

Etsy Reviews Scraper With Sentiment & Analytics is an Apify Actor that fetches an Etsy shop's public reviews — text, rating, date, buyer, seller reply, and the reviewed listing's details — and can optionally classify each review with an AI model (sentiment, topics, language, spam signal) or compute non-AI shop-level review analytics. No Etsy account or login is required; it reads the same review data any shop visitor already sees. It's built for Etsy sellers monitoring their own reviews, marketplace researchers comparing shops, and developers or AI engineers building review-analysis and RAG pipelines on top of Etsy review data.

### 🔓 What Etsy review data is publicly available to scrape?

Etsy shop reviews are public — anyone who opens a shop's page can read every review, its star rating, the seller's reply, and the listing it was left for, without signing in.

| Data Category | Publicly Available | Restricted (Seller's Private Shop Manager Dashboard) |
| --- | --- | --- |
| Review text & star rating | ✅ | ❌ |
| Buyer display name & public profile link | ✅ | ❌ |
| Review date | ✅ | ❌ |
| Seller's public reply to a review | ✅ | ❌ |
| Reviewed listing's title, photos & URL | ✅ | ❌ |
| Shop's aggregate rating & total review count | ✅ | ❌ |
| Shop's internal sales, traffic & order analytics | ❌ | ✅ |
| Buyer's contact details or full purchase history | ❌ | ✅ |

Etsy Reviews Scraper With Sentiment & Analytics only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

### 📋 What data can I extract with Etsy Reviews Scraper With Sentiment & Analytics?

Etsy Reviews Scraper With Sentiment & Analytics returns three groups of fields per row: who left the review and what it's about, the rating plus AI-derived signals, and a shop-wide analytics rollup.

#### 🧾 Review & buyer identity fields

| Field Name | Description |
| --- | --- |
| `type` | Row type: `"review"` for a review record, `"shopAnalytics"` for the one per-shop summary row |
| `receipt_id` | Etsy's internal ID for the transaction/review; `null` on a `shopAnalytics` row |
| `buyer_user_id` | Buyer's numeric Etsy account ID, when it can be recovered from the page data; not always present |
| `buyer_real_name` | Buyer's displayed name on the review |
| `buyer_login_name` | Buyer's public username, taken from their profile link, when available |
| `buyer_image` | URL of the buyer's avatar image (default avatar if none is set) |
| `listing_title` | Title of the listing the review was left for |
| `review` | The review text |
| `appreciation_image` | URL of a photo the buyer attached to the review, if any |
| `response` | Seller's public reply text, if the seller responded |
| `date` | Review date (`YYYY-MM-DD HH:MM:SS`) |
| `product_details.shop_average_rating` | Shop's average rating as shown on the page |
| `product_details.shop_total_rating_count` | Shop's total rating count, as a string |
| `product_details.product_url` | URL of the reviewed listing |
| `product_details.seller_name` | Shop name |
| `product_details.seller_url` | URL of the shop |
| `product_details.listingImageFull` | Full-size URL of the reviewed listing's own photo |
| `product_details.image` | Array of the listing photo at Etsy's other standard image sizes |

#### ⭐ Rating, AI sentiment & spam-signal fields

| Field Name | Description |
| --- | --- |
| `product_rating` | Star rating for the review, 1–5 |
| `reviews_count` | Shop's total review count, as shown on the page at scrape time |
| `sentiment` | AI-classified sentiment: `"positive"`, `"neutral"`, or `"negative"` — `null` unless `enableAiAnalysis` is on |
| `topics` | Up to 3 AI-detected topics from a fixed Etsy-review set (e.g. `"shipping speed"`, `"item quality"`, `"sizing/fit"`) — `null` unless AI analysis is on |
| `language` | ISO 639-1 language code of the review text, AI-detected — `null` unless AI analysis is on |
| `spamScore` | AI-estimated likelihood (0.0–1.0) that the review is fake, spam, or boilerplate — `null` unless AI analysis is on |
| `isLikelyFake` | Boolean, `true` when `spamScore >= 0.6` — `null` unless AI analysis is on |

#### 📊 Shop analytics & metadata fields

| Field Name | Description |
| --- | --- |
| `shopAnalytics` | Present only on the shop-level summary row; `null` on review rows |
| `shopAnalytics.shopName` | Shop the analytics were computed for |
| `shopAnalytics.sampleSize` | Number of reviews this run collected for the shop |
| `shopAnalytics.ratingDistribution` | Count of sampled reviews at each star rating, `{"1":.., "2":.., "3":.., "4":.., "5":..}` |
| `shopAnalytics.responseRate` | Fraction of sampled reviews the seller replied to |
| `shopAnalytics.averageReviewLength` | Average review text length (characters) in the sample |
| `shopAnalytics.reviewsWithPhotosPct` | Fraction of sampled reviews with a buyer photo |
| `shopAnalytics.reviewVelocityPerMonth` | Reviews per month across the sample's date range; `null` if all sampled reviews share one date |
| `shopAnalytics.dateRangeStart` / `dateRangeEnd` | Earliest / latest review date in the sample |
| `shopAnalytics.note` | Fixed disclaimer that this is a run-bounded sample, not a full-shop census |
| `scrapedAt` | UTC timestamp the row was scraped, ISO 8601 |

#### 🤖 Add-on: Need additional Etsy data?

Pair this with other Scraper-Engine marketplace scrapers for a fuller picture: **eBay Search Scraper** and **eBay Product Details Scraper — Watchlist & Price Details** cover product and pricing data if you're benchmarking Etsy sellers against other marketplaces, and **Realtor.com Agents by Zip Code Scraper With Listings & Reviews** applies this same review-plus-analytics pattern to a different platform.

### 🆚 How does Etsy Reviews Scraper With Sentiment & Analytics differ from the official Etsy API?

Etsy's official Open API v3 can return shop reviews, but only via the shop's internal numeric `shop_id` and a registered developer app's API key, while Etsy Reviews Scraper With Sentiment & Analytics takes a shop URL or plain name directly and adds AI sentiment/topic classification and shop analytics the official endpoint doesn't compute.

| Feature | Etsy Open API v3 | Etsy Reviews Scraper With Sentiment & Analytics |
| --- | --- | --- |
| Shop identifier needed | Numeric `shop_id`, resolved via a separate lookup call | Shop URL or plain shop name |
| Access setup | Register a developer app and obtain an API key; OAuth for private-scope endpoints | None beyond an Apify account — set input and run |
| Published rate limit | Up to 10,000 requests/day and 10 requests/second per API key, raised only on request to Etsy (developers.etsy.com, checked 2026-07-30) | Governed by this Actor's own `maxRetries` / `retryDelaySeconds` inputs, not a per-key API quota |
| AI sentiment/topic/spam classification | Not provided | Optional, built in (off by default) |
| Shop-level review analytics rollup | Not provided | Optional, built in (on by default) |
| Output format | Raw API JSON matching Etsy's own schema | Normalized JSON dataset, exportable to JSON/CSV/Excel from Apify |

Use the official API if you already hold Etsy-issued app credentials, need write access, or are building inside Etsy's own app-review terms. Use this Actor when you want review data for one or more shops immediately, without an app-approval step, plus built-in sentiment and analytics.

### ▶️ How to use Etsy Reviews Scraper With Sentiment & Analytics

Etsy Reviews Scraper With Sentiment & Analytics runs on Apify like any other Actor — no Etsy credentials needed.

1. Open the Actor's page on the Apify Store or in your Apify Console.
2. Add one or more Etsy shop URLs or plain shop names to `startUrls` (required).
3. Set `maxReviewsPerShop`, and optionally turn on `enableAiAnalysis` (with an `aiApiKey`) and/or `includeShopAnalytics`.
4. Click **Start**.
5. Download results from the dataset as JSON, CSV, or Excel, or stream them via the Apify API.

#### How to scale to bulk review extraction

`startUrls` accepts an array, so a single run can process any number of shops — each is fetched in turn and every review lands in one combined dataset, distinguishable by `product_details.seller_name` (or `shopAnalytics.shopName` on summary rows). There's no separate "bulk" input: add more shop URLs or names to the same list and they're all scraped in that run.

### 🎯 What can you do with Etsy review data?

- 🏪 **Etsy sellers** monitoring reputation use `product_rating`, `sentiment`, and `response` to spot unanswered negative reviews and reply before they drag down the shop's rating.
- 📈 **Marketplace researchers** comparing shops use `shopAnalytics.ratingDistribution` and `shopAnalytics.responseRate` across multiple `startUrls` to benchmark seller responsiveness at a glance.
- 🕵️ **Trust & quality teams** screening for fake reviews use `spamScore` and `isLikelyFake` to flag boilerplate-looking reviews before trusting a shop's public rating.
- 🔍 **Product teams** tracking listing feedback use `listing_title` and `topics` to see which specific products draw complaints about `"sizing/fit"` or `"shipping speed"`.
- 🤖 **AI engineers** building a review-insights agent feed `review`, `sentiment`, and `topics` directly into a RAG index or an LLM prompt — typed JSON needs no HTML parsing before it reaches the model.

Because output is already structured JSON, any of these fields can be passed straight into an agent tool call without extra parsing.

### 🛡️ How does Etsy Reviews Scraper With Sentiment & Analytics handle rate limits and blocking?

Etsy Reviews Scraper With Sentiment & Analytics runs through Apify Proxy on the residential tier by default — the tier Etsy's shop-review endpoint needs for reliable access — and you can select different proxy groups via `proxyConfiguration` if you prefer. Each shop starts with a fresh browser-impersonated session (via `curl_cffi`, not a headless browser), built by first visiting the shop's public page. If Etsy returns a 403 mid-pagination — usually an expired session cookie — the Actor opens a new session and retries the same page, up to 3 times, before giving up on that attempt. If a shop is still blocked, the whole shop is retried from scratch with a new proxy session, up to 3 times total; reviews already collected are kept, not discarded. Ordinary request failures use the `maxRetries` (default 3) and `retryDelaySeconds` (default 5, increasing per attempt) inputs. If a shop remains blocked after all retries, the Actor logs it and moves on to the next shop instead of failing the whole run.

### ⬇️ Input

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `startUrls` | Yes | array | Etsy shop URLs (e.g. `https://www.etsy.com/shop/ShopName`) or plain shop names. Add multiple shops — the actor scrapes each one and combines all reviews into a single dataset. | `["https://www.etsy.com/shop/HereafterLA"]` |
| `maxReviewsPerShop` | No | integer | Maximum number of reviews to fetch per shop (1–5000). Paginates until this limit or until no more reviews are available. Default: `100`. | `100` |
| `maxRetries` | No | integer | How many times to retry a review-page request before giving up on it. Min `0`, max `10`. Default: `3`. | `3` |
| `retryDelaySeconds` | No | integer | Base delay between retries, in seconds (increases with each retry attempt). Min `1`, max `60`. Default: `5`. | `5` |
| `includeShopAnalytics` | No | boolean | Push one extra summary row (`type="shopAnalytics"`) per shop with rating distribution, response rate, average review length, %-with-photos, and review velocity. Default: `true`. | `true` |
| `enableAiAnalysis` | No | boolean | Classify each review's text into sentiment, up to 3 topics, detected language, and a spam/fake-review signal. Off by default — requires an API key. Default: `false`. | `false` |
| `aiModel` | No | string (enum) | AI model/provider for classification, only used when `enableAiAnalysis` is on. Provider is auto-detected from the name prefix (`claude-`=Anthropic, `gpt-`/`o1`/`o3`=OpenAI, `gemini-`=Google, `grok-`=xAI, `deepseek-`=DeepSeek, `sonar`=Perplexity, `mistral-`=Mistral). Enum: `claude-haiku-4-5`, `claude-sonnet-5`, `claude-opus-4-8`, `claude-fable-5`, `gpt-4o-mini`, `gpt-4o`, `gpt-4.1-mini`, `gpt-4.1`, `o3-mini`, `o1`, `gemini-2.0-flash-lite`, `gemini-2.0-flash`, `gemini-1.5-pro`, `gemini-2.5-flash`, `gemini-2.5-pro`, `grok-2-latest`, `grok-3-mini`, `grok-3`, `grok-beta`, `deepseek-chat`, `deepseek-reasoner`, `sonar`, `sonar-pro`, `sonar-reasoning`, `mistral-small-latest`, `mistral-large-latest`. Default: `claude-haiku-4-5`. | `claude-haiku-4-5` |
| `aiApiKey` | No | string (secret) | API key for the selected AI provider. Only needed when AI analysis is enabled. Falls back to an environment variable on the account if left empty (e.g. `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GEMINI_API_KEY`). | `sk-ant-...` |
| `proxyConfiguration` | No | object | Apify Proxy used to reach Etsy. Leave the default (or empty) for residential proxy, which this actor needs for reliable access. Select different proxy groups to use those instead. | `{ "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }` |

#### Example input

```json
{
  "startUrls": [
    { "url": "https://www.etsy.com/shop/HereafterLA" },
    "AnotherEtsyShopName"
  ],
  "maxReviewsPerShop": 200,
  "maxRetries": 3,
  "retryDelaySeconds": 5,
  "includeShopAnalytics": true,
  "enableAiAnalysis": true,
  "aiModel": "claude-haiku-4-5",
  "aiApiKey": "sk-ant-your-key-here",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### ⬆️ Output

Etsy Reviews Scraper With Sentiment & Analytics writes typed, normalized JSON rows with a consistent schema across runs, viewable as a dataset table in the Apify Console or exportable to JSON, CSV, Excel, XML, or RSS. Two row shapes share the dataset, distinguished by `type`: `"review"` rows carry the review data, and one `"shopAnalytics"` row per shop (when `includeShopAnalytics` is on) carries the derived rollup, with every review-only field set to `null`.

#### Example output

A `"review"` row:

```json
{
  "type": "review",
  "receipt_id": 4934801880,
  "buyer_user_id": 84577298,
  "buyer_real_name": "Therese M.",
  "buyer_login_name": "b8ddtlb335qm713s",
  "buyer_image": "https://i.etsystatic.com/site-assets/images/avatars/default_avatar.png?width=75",
  "listing_title": "Desert Garden Wooden Birthday Card, Blank Inside",
  "review": "Beautifully made and shipped fast. Will order again for sure!",
  "appreciation_image": null,
  "product_rating": 5,
  "response": "Thank you so much for the kind words!",
  "reviews_count": 10481,
  "date": "2026-02-08 00:00:00",
  "product_details": {
    "shop_average_rating": "4.9",
    "shop_total_rating_count": "10481",
    "product_url": "https://www.etsy.com/listing/629949817/desert-garden-wooden-birthday-card",
    "seller_name": "HereafterLA",
    "seller_url": "https://www.etsy.com/shop/HereafterLA",
    "listingImageFull": "https://i.etsystatic.com/12345678/il_fullxfull.987654321.jpg",
    "image": [
      "https://i.etsystatic.com/12345678/il_75x75.987654321.jpg",
      "https://i.etsystatic.com/12345678/il_570xN.987654321.jpg"
    ]
  },
  "sentiment": "positive",
  "topics": ["item quality", "shipping speed"],
  "language": "en",
  "spamScore": 0.05,
  "isLikelyFake": false,
  "shopAnalytics": null,
  "scrapedAt": "2026-07-30T09:12:41Z"
}
```

A `"shopAnalytics"` row (only when `includeShopAnalytics` is on):

```json
{
  "type": "shopAnalytics",
  "receipt_id": null,
  "buyer_real_name": null,
  "listing_title": null,
  "review": null,
  "product_rating": null,
  "response": null,
  "date": null,
  "sentiment": null,
  "product_details": null,
  "shopAnalytics": {
    "shopName": "HereafterLA",
    "sampleSize": 200,
    "ratingDistribution": { "1": 2, "2": 1, "3": 4, "4": 21, "5": 172 },
    "responseRate": 0.18,
    "averageReviewLength": 68.4,
    "reviewsWithPhotosPct": 0.06,
    "reviewVelocityPerMonth": 24.3,
    "dateRangeStart": "2025-08-11",
    "dateRangeEnd": "2026-07-24",
    "note": "Computed from the reviews collected in THIS run (bounded by Max reviews per shop) — a sample rollup, not a full-shop census."
  },
  "scrapedAt": "2026-07-30T09:13:02Z"
}
```

### ⚙️ How does it work?

Each run starts by fetching the Etsy shop's public page to establish a browser-like session — via `curl_cffi`'s Chrome impersonation, not a headless browser — then calls the same internal AJAX endpoint the shop page itself uses to load its review widget, paginating 10 reviews at a time through Apify's residential proxy pool. The returned HTML is parsed with BeautifulSoup into the fixed row schema documented above, so a change to Etsy's markup only touches the parsing logic — the field names your integration reads stay the same across runs. Only reviews the shop's own page already displays publicly are returned; no Etsy credentials are involved. Optional AI classification and shop analytics are computed on that same collected data, with no extra requests to Etsy.

### 🔌 Integrations

Etsy Reviews Scraper With Sentiment & Analytics works like any Apify Actor — call it from your own code, or wire it into automation tools you already use.

#### 🐍 Calling it programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")
run = client.actor("<your-username>/etsy-reviews-scraper-with-sentiment-and-analytics").call(
    run_input={
        "startUrls": ["https://www.etsy.com/shop/HereafterLA"],
        "maxReviewsPerShop": 200,
        "includeShopAnalytics": True,
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["listing_title"], item["product_rating"], item["sentiment"])
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

#### No-code tools (n8n, Make, LangChain)

In **n8n**, use the Apify node (or an HTTP Request node) pointed at this Actor's run endpoint, feeding `startUrls` from an earlier step. In **Make**, the Apify app's "Run Actor and get dataset items" module does the same. In **LangChain**, the community Apify integration (`ApifyWrapper` / `ApifyDatasetLoader`) can start this Actor and load its dataset directly as documents for a retrieval chain.

### ⚖️ Is it legal to scrape Etsy reviews?

Scraping publicly visible Etsy shop reviews is generally lawful — the reviews, ratings, and seller replies here are visible to any visitor without logging in, and no account credentials or authentication bypass is involved. Etsy Reviews Scraper With Sentiment & Analytics returns only that publicly available data. Because reviews carry personal data about identifiable buyers — a display name, and often a public username — storing or reusing them is subject to data-protection law such as GDPR (EU/UK) and CCPA (California), which govern retention and use of that data separately from whether the scrape itself is lawful. You should also review Etsy's own Terms of Use before large-scale or repeated collection. Consult legal counsel if your use case involves bulk storage of personal data.

### ❓ Frequently asked questions

#### What Etsy review fields does this scraper return?

The top fields are `review` (text), `product_rating`, `buyer_real_name`, `date`, and `response` — plus optional `sentiment`, `topics`, and `spamScore` when AI analysis is on. See [What data can I extract](#-what-data-can-i-extract-with-etsy-reviews-scraper-with-sentiment--analytics) above for the full list.

#### Does it require an Etsy account or login?

No. It reads the same public review widget any shop visitor sees, using a browser-impersonated session — no Etsy username, password, or Etsy-issued API key is needed.

#### How many reviews can I extract in one run?

Up to `maxReviewsPerShop` per shop (1–5000, default 100), for as many shops as you add to `startUrls` in a single run — reviews are paginated 10 per page until that limit or the shop's actual review count is reached, whichever comes first.

#### What happens if an Etsy shop has no reviews or blocks the request?

If a shop has no reviews, the Actor moves on without adding review rows for it (a `shopAnalytics` row with `sampleSize: 0` is still pushed if enabled). If Etsy blocks the session (HTTP 403), the Actor opens a fresh session and retries, and retries the whole shop with a new proxy session up to 3 times before skipping it — any reviews already collected for that shop are kept in the dataset.

#### Can I scrape multiple Etsy shops at once?

Yes — `startUrls` is an array. Add as many shop URLs or plain shop names as you want and they're all combined into one dataset in a single run.

#### Does it work with Claude, ChatGPT, and other AI agent tools?

Yes, in two ways: the Actor itself is callable as an HTTP endpoint via the Apify API from any agent framework, and separately, its own AI review-classification step can call Claude, GPT, Gemini, Grok, DeepSeek, Perplexity, or Mistral models through the `aiModel` input.

#### How does this variant differ from a plain Etsy reviews scraper?

It returns the same core review fields — buyer, rating, text, seller reply, listing details — plus two additional, optional capabilities: AI sentiment/topic/spam classification per review, and a non-AI shop-level analytics summary row. Both are computed from reviews already collected, so turning them off costs nothing extra in requests to Etsy.

#### Does it return data in a format LLMs can use directly?

Yes. Every row is typed, normalized JSON with the same field names across runs — no HTML parsing or CSS selectors needed. Pass it straight to an LLM prompt, a vector store, or an agent tool.

#### What happens when Etsy changes its layout or anti-bot system?

The scraper is maintained, and the output schema is designed to stay stable across Etsy layout changes — updates land in the parsing logic, not in the field names your integration depends on. No specific turnaround time is promised.

#### Can I use it without managing proxies or browser infrastructure?

Yes. Apify Proxy (residential tier, by default) and session handling are built in and run automatically — you don't provision or rotate proxies yourself, and there's no browser to install or maintain.

#### Which review fields work best for AI training data and RAG indexing?

For RAG, index `review` (the free text) alongside `listing_title`, `sentiment`, and `topics` as filterable metadata. For training data, `product_rating`, `date`, and `receipt_id` are the most consistently structured fields across every record. All fields return as typed primitives — strings, integers, booleans, or `null` — never one bag of raw text.

### 🔗 Related scrapers

More Scraper-Engine scrapers for marketplace and review data:

| Scraper | What it extracts |
| --- | --- |
| eBay Search Scraper | eBay search-result listings — titles, prices, images |
| eBay Product Details Scraper — Watchlist & Price Details | Tracked eBay listings' prices over time, with drop alerts |
| Shein Search Products Scraper | Shein product search results |
| Realtor.com Agents by Zip Code Scraper With Listings & Reviews | Real-estate agents by zip code, with their listings and reviews |

### 💬 Your feedback

Found a bug, or need a field this scraper doesn't return? Let us know through the Issues tab on this Actor's Apify Store page — reports get read and the Actor gets updated.

# Actor input Schema

## `startUrls` (type: `array`):

Add Etsy shop URLs (e.g. https://www.etsy.com/shop/ShopName) or plain shop names. Add multiple shops — the actor scrapes each one and combines all reviews into a single dataset.

## `maxReviewsPerShop` (type: `integer`):

Maximum number of reviews to fetch per shop (1–5000). The actor paginates through review pages until this limit or until no more reviews are available. Default: 100.

## `maxRetries` (type: `integer`):

How many times to retry a review-page request before giving up on it. Default: 3.

## `retryDelaySeconds` (type: `integer`):

Base delay between retries, in seconds (increases with each retry attempt). Default: 5.

## `includeShopAnalytics` (type: `boolean`):

After each shop's reviews are collected, push one extra summary row (type="shopAnalytics") with rating distribution, response rate, average review length, % of reviews with photos, and review velocity (reviews/month) computed from the reviews collected in this run. Default: enabled.

## `enableAiAnalysis` (type: `boolean`):

When enabled, each review's text is classified with an AI model into sentiment (positive/neutral/negative), up to 3 topics (e.g. shipping speed, item quality, sizing/fit), detected language, and a spam/fake-review signal. Off by default — requires an API key below.

## `aiModel` (type: `string`):

Only used when AI review analysis is enabled. Provider is auto-detected from the name: claude-*=Anthropic, gpt-*/o1/o3=OpenAI, gemini-*=Google, grok-*=xAI, deepseek-*=DeepSeek, sonar*=Perplexity, mistral-\*=Mistral. Cheaper mini/flash/haiku models are recommended for this kind of classification.

## `aiApiKey` (type: `string`):

API key for the selected AI provider. Only needed when AI review analysis is enabled. Falls back to an environment variable on the account if left empty (e.g. ANTHROPIC\_API\_KEY, OPENAI\_API\_KEY, GEMINI\_API\_KEY).

## `proxyConfiguration` (type: `object`):

Configures the Apify Proxy used to reach Etsy. Leave the default (or empty) to use residential proxy, which this actor needs for reliable access — up to 3 retries per shop. You may select different proxy groups here and they will be used instead.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.etsy.com/shop/HereafterLA"
  ],
  "maxReviewsPerShop": 100,
  "maxRetries": 3,
  "retryDelaySeconds": 5,
  "includeShopAnalytics": true,
  "enableAiAnalysis": false,
  "aiModel": "claude-haiku-4-5",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.etsy.com/shop/HereafterLA"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/etsy-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": ["https://www.etsy.com/shop/HereafterLA"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/etsy-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.etsy.com/shop/HereafterLA"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraper-engine/etsy-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraper-engine/etsy-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/7gSAXWjHCLGVSyJR4/builds/QafY8FCwe2xcPciuO/openapi.json