# Etsy Reviews Scraper — Buyer Feedback & Seller Replies (`astravalabs/etsy-reviews-scraper`) Actor

Export buyer reviews from up to 50 Etsy shops per run. Get ratings, full text, buyer names, dates, photos, reviewed listings, seller replies, and shop IDs with exact per-shop and whole-run cost caps.

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

## Pricing

from $4.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 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 — Buyer Feedback & Seller Replies

Export buyer reviews from one Etsy shop or up to 50 shops in a single run. Get
one clean row per review with the star rating, full text, buyer name, date,
buyer-uploaded photos, reviewed listing, and the seller's public reply—without
configuring proxies or CAPTCHA handling.

Use it for sentiment analysis, product-quality research, competitor monitoring,
customer-service analysis, or recurring review datasets.

### Quick start

```json
{
  "shops": [
    "ArtFablePets",
    "https://www.etsy.com/shop/WilshireGoodsShop"
  ],
  "reviewsSort": "Recency",
  "maxReviews": 100,
  "maxTotalResults": 5000
}
```

`shops` accepts bare shop names and full Etsy shop URLs. Blank values and
duplicates are removed before requests begin.

### What you get

Each default-dataset row represents one buyer review:

```json
{
  "shop": "ArtFablePets",
  "shop_id": 16875973,
  "review_id": "4935496659",
  "rating": 5,
  "text": "Beautiful work and exactly what I hoped for.",
  "buyer": "Alex",
  "review_date": "Mar 7, 2026",
  "listing_id": "1234567890",
  "listing_title": "Personalized pet portrait",
  "photos": ["https://i.etsystatic.com/iap/.../iap_300x300.jpg"],
  "seller_response": "Thank you so much!",
  "seller_response_date": "Mar 8, 2026",
  "scraped_at": "2026-07-18T12:00:00+00:00"
}
```

Export the dataset as JSON, CSV, Excel, XML, RSS, or JSONL. Every raw output
field is also visible in the Actor's dataset view.

### Inputs and cost controls

| Input | Default | Description |
|---|---:|---|
| `shops` | required | 1–50 unique Etsy shop names or URLs |
| `maxReviews` | `100` | Per-shop review ceiling; use `0` to paginate until the history ends |
| `maxTotalResults` | `5000` | Exact whole-run ceiling across all submitted shops |
| `reviewsSort` | `Recency` | Newest first or Etsy's `Relevancy` ordering |

The two limits work together. For example, `maxReviews: 100` and
`maxTotalResults: 1000` means no shop can contribute more than 100 rows and the
entire batch can never save more than 1,000. To request a complete history
beyond 5,000 reviews, set `maxReviews` to `0` and intentionally raise
`maxTotalResults`.

The Actor also respects an Apify maximum cost per run. If that spending limit
accepts only part of a final page, the dataset and `RUN_REPORT` count only the
reviews actually persisted.

There is no rating-filter input. Every row contains `rating`, so filter the
dataset or exported file to 1–5 stars without paying for an opaque second record
type or changing pagination semantics.

### Pricing

The price is **$4 per 1,000 saved reviews** ($0.004 per result). There is no
separate Actor-start charge to the user, and proxy handling is included.

| Saved reviews | Result charge |
|---:|---:|
| 100 | $0.40 |
| 1,000 | $4.00 |
| 5,000 (default whole-run cap) | $20.00 |

You pay only for review rows saved to the default dataset. `RUN_REPORT` is
stored separately and is not a billed result.

### Speed and scale

Shops run in parallel. Each active shop uses one proxy session, fetches up to
four review pages concurrently, and shares a 48-request global ceiling. Live
local measurements of the selected production configuration:

| Run shape | Time range | Reviews | Successful samples |
|---|---:|---:|---:|
| 1 shop × up to 100 reviews | 4.7–5.5s | 94 | 2/2 |
| 10 shops × up to 100 reviews | 7.0s | 994 | 2/2 |
| 50 shops × up to 20 reviews | 9.3–11.1s | 1,000 | 2/2 |

All 26 benchmark samples completed without a failed shop. Four pages per shop
outperformed 1, 2, 3, and 6; a 48-request global ceiling was stable while 64
caused a severe slowdown in one sample. Times vary with proxy warmup, Etsy
response latency, review-history depth, and retry conditions.

### Use cases

- **Sentiment and topic analysis:** group complaints, praise, product language,
  and recurring quality themes from full review text.
- **Competitor monitoring:** compare recent buyer feedback across as many as 50
  shops in one repeatable run.
- **Customer-service research:** measure which reviews receive seller replies
  and inspect how competing sellers respond.
- **Listing-level enrichment:** use `listing_id` and `listing_title` to connect
  each review to catalog or product records from the companion Actors.
- **Buyer-photo research:** collect the appreciation-photo URLs Etsy exposes on
  public review cards.

### Run status and partial results

The key-value store record `RUN_REPORT` preserves normalized input order and
gives every shop an explicit status:

- `completed` — the history ended normally or reached `maxReviews`.
- `capped` — the shop stopped at `maxTotalResults` or the Apify spending limit.
- `not_started` — the whole-run limit was reached before this shop acquired a worker.
- `failed` — warmup, retry recovery, pagination safety, or storage failed.

It also contains persisted review/page counts, machine-readable termination
reasons, run totals, effective concurrency, proxy sessions, retries, fetch
outcomes, and estimated bandwidth. Reviews saved before a later page failure
remain available and are counted accurately.

### API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/astravalabs~etsy-reviews-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"shops":["ArtFablePets"],"maxReviews":100}'
```

For large histories, start the Actor asynchronously and read the default
dataset after the run succeeds.

### Companion Etsy actors

- [Etsy Listings Scraper](https://apify.com/astravalabs/etsy-listings-scraper) — discover listings in Etsy search and track organic and sponsored placement.
- [Etsy Product Scraper](https://apify.com/astravalabs/etsy-product-scraper) — enrich reviewed listing IDs with complete product details, variations, demand, shipping, and policies.
- [Etsy Shop Catalog Scraper](https://apify.com/astravalabs/etsy-shop-catalog-scraper) — pair buyer feedback with each shop's complete current catalog.
- [Etsy Keyword Research Tool](https://apify.com/astravalabs/etsy-keyword-research-tool) — collect Etsy autocomplete and long-tail keyword ideas.

### FAQ

**Does this scrape reviews for one specific listing?**

Not yet. The current input is shop-based, and each row identifies the reviewed
listing. Use `listing_id` to group the output by product.

**Why did a shop return fewer rows than `maxReviews`?**

`maxReviews` is a ceiling, not a target. The Actor stops when Etsy has no more
public shop-review pages. Check `RUN_REPORT` for the exact status and reason.

**Can I export only negative reviews?**

Filter the `rating` column after collection. A client-side input filter would
still need to download every page and would make the per-shop cap ambiguous.

**Are seller replies and buyer photos always present?**

No. They are populated only when Etsy exposes them on that public review.

**Can I collect more than 5,000 reviews?**

Yes. Raise `maxTotalResults`; for an uncapped per-shop history, also set
`maxReviews` to `0`.

> Unofficial. Not affiliated with, endorsed by, or sponsored by Etsy, Inc.
> “Etsy” is a trademark of Etsy, Inc., used here descriptively.

# Actor input Schema

## `shops` (type: `array`):

Etsy shops to scrape reviews for — bare shop slugs ("ArtFablePets") or full shop URLs ("https://www.etsy.com/shop/ArtFablePets"). Both are reduced to the slug.

## `reviewsSort` (type: `string`):

Order reviews are fetched in: most recent first, or Etsy's relevancy ranking.

## `maxReviews` (type: `integer`):

Cap reviews saved per shop. Defaults to 100 (a solid sample and a cost/time guardrail). Set to 0 to scrape a shop's ENTIRE review history — can be slow for shops with thousands of reviews.

## `maxTotalResults` (type: `integer`):

Whole-run cap across all shops. Defaults to 5,000 reviews, making the maximum result charge predictable even when many large review histories are submitted together.

## Actor input object example

```json
{
  "shops": [
    "ArtFablePets"
  ],
  "reviewsSort": "Recency",
  "maxReviews": 100,
  "maxTotalResults": 5000
}
```

# Actor output Schema

## `reviews` (type: `string`):

The dataset: one row per review with rating, text, buyer, date, item, photos, and seller reply.

## `runReport` (type: `string`):

Ordered per-shop status, termination reason, persisted review/page counts, run totals, and retry diagnostics.

# 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 = {
    "shops": [
        "ArtFablePets"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("astravalabs/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 = { "shops": ["ArtFablePets"] }

# Run the Actor and wait for it to finish
run = client.actor("astravalabs/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 '{
  "shops": [
    "ArtFablePets"
  ]
}' |
apify call astravalabs/etsy-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/LGD4RaVPyTTEZFkhd/builds/4QtrO6Ux5cSDO5E7g/openapi.json