# Etsy Reviews Sentiment Analyzer (`axlymxp/etsy-reviews-sentiment-analyzer`) Actor

Analyze Etsy shop reviews at scale. Get a per-shop sentiment score, positive/negative/neutral breakdown, star distribution, and the top praise and complaint themes. Optionally export every review with its sentiment label. Great for competitor research and product insight. No API key required.

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

## Pricing

from $3.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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Sentiment Analyzer — Shop Sentiment, Themes & Star Breakdown

Turn raw Etsy reviews into insight. Point the actor at one or more shops (by name,
URL, or ID — or discover them by keyword) and get a per-shop **sentiment report**:
an overall sentiment score, positive/negative/neutral counts, the star
distribution, and the most common **praise and complaint themes**. Optionally
export every individual review tagged with its own sentiment. **No API key, no
Etsy login required.**

### What Data You Get

#### Per-shop summary

| Field                                                 | Description                              |
| ----------------------------------------------------- | ---------------------------------------- |
| `shop_name`, `shop_url`, `shop_id`                    | Shop identity                            |
| `total_reviews_on_etsy`                               | Total reviews the shop has               |
| `reviews_analyzed`                                    | How many were analyzed this run          |
| `avg_rating`                                          | Average star rating of analyzed reviews  |
| `sentiment_score`                                     | −1 (very negative) to +1 (very positive) |
| `sentiment_label`                                     | `very_positive` … `very_negative`        |
| `positive_count` / `neutral_count` / `negative_count` | Review breakdown                         |
| `recommended_pct`                                     | % of reviewers who recommend the shop    |
| `response_rate_pct`                                   | % of reviews the seller replied to       |
| `star_percents`                                       | Etsy's 1–5 star distribution             |
| `top_positive_themes`                                 | Most common praise keywords              |
| `top_negative_themes`                                 | Most common complaint keywords           |

#### Optional per-review rows (`emitReviews`)

`rating`, `sentiment`, `language`, `review`, `is_recommended`,
`has_seller_response`, `listing_title`, `review_date`.

### Use Cases

- **Competitor research** — see exactly what a rival's customers love and hate.
- **Product insight** — surface recurring complaints (shipping, quality, sizing).
- **Shop audit** — benchmark your own shop's sentiment against others.
- **Due diligence** — vet a supplier or partner before working with them.

### How to Use

1. Add **shops** (names, URLs, or IDs) — or set a **Search Query** to find them.
2. Choose **Max Reviews Per Shop** (default 100).
3. Toggle **Emit Individual Reviews** if you want every review row.
4. Run.

#### Example Input

```json
{
    "shops": ["CandlesandFavors"],
    "maxReviewsPerShop": 100,
    "emitReviews": false,
    "language": "en"
}
````

#### Example Output (shop summary)

```json
{
    "row_type": "shop_summary",
    "shop_id": 5588285,
    "shop_name": "CandlesandFavors",
    "shop_url": "https://www.etsy.com/shop/CandlesandFavors",
    "total_reviews_on_etsy": 12235,
    "reviews_analyzed": 100,
    "avg_rating": 4.86,
    "sentiment_score": 0.93,
    "sentiment_label": "very_positive",
    "positive_count": 94,
    "neutral_count": 3,
    "negative_count": 3,
    "recommended_pct": 96.0,
    "response_rate_pct": 12.0,
    "star_percents": { "five": 95, "four": 2, "three": 1, "two": 1, "one": 1 },
    "top_positive_themes": ["quality", "fast", "beautiful", "cute", "perfect"],
    "top_negative_themes": ["shipping", "late", "broken"],
    "scraped_at": "2026-06-09T00:00:00Z"
}
```

### Pricing

Pay Per Event — billed per emitted row. Keeping **Emit Individual Reviews** off
returns one compact summary per shop for the lowest cost.

### Scheduling & Automation

Track how a shop's sentiment shifts over time:

1. Open your run → **Schedule** tab, set a CRON expression.
2. Add a **webhook** to POST summaries to your dashboard or sheet.

```
POST https://api.apify.com/v2/acts/axlymxp~etsy-reviews-sentiment-analyzer/runs
Authorization: Bearer YOUR_API_TOKEN
```

### Use with AI Agents (MCP)

Available on Apify's MCP Server — connect to Claude or ChatGPT and ask
*"what do customers complain about most in this shop?"*

### FAQ

**How is sentiment calculated?**
A transparent rule-based model: 4–5★ = positive, 3★ = neutral, 1–2★ = negative.
The shop score is the mean rating mapped to −1..+1. Themes come from keyword
frequency in positive vs. negative reviews.

**Can I analyze reviews in one language only?**
Yes — set the `language` field (e.g. `en`) to filter.

**Do I need an Etsy API key?**
No.

**Can I export individual reviews?**
Yes — enable *Emit Individual Reviews* to get one labeled row per review.

# Actor input Schema

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

Shop names, Etsy shop URLs, or numeric shop IDs to analyze.

## `searchQuery` (type: `string`):

Instead of naming shops, discover shops to analyze by keyword.

## `maxShops` (type: `integer`):

Maximum shops to analyze when using a search query.

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

How many recent reviews to analyze per shop.

## `emitReviews` (type: `boolean`):

Also output one row per individual review with its sentiment label.

## `language` (type: `string`):

Optional ISO language code to only analyze reviews in that language (e.g. 'en').

## Actor input object example

```json
{
  "shops": [
    "CandlesandFavors"
  ],
  "maxShops": 20,
  "maxReviewsPerShop": 100,
  "emitReviews": false
}
```

# 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": [
        "CandlesandFavors"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("axlymxp/etsy-reviews-sentiment-analyzer").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": ["CandlesandFavors"] }

# Run the Actor and wait for it to finish
run = client.actor("axlymxp/etsy-reviews-sentiment-analyzer").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": [
    "CandlesandFavors"
  ]
}' |
apify call axlymxp/etsy-reviews-sentiment-analyzer --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Etsy Reviews Sentiment Analyzer",
        "description": "Analyze Etsy shop reviews at scale. Get a per-shop sentiment score, positive/negative/neutral breakdown, star distribution, and the top praise and complaint themes. Optionally export every review with its sentiment label. Great for competitor research and product insight. No API key required.",
        "version": "1.0",
        "x-build-id": "zAWvTr0ipPcNeFsyv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/axlymxp~etsy-reviews-sentiment-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-axlymxp-etsy-reviews-sentiment-analyzer",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/axlymxp~etsy-reviews-sentiment-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-axlymxp-etsy-reviews-sentiment-analyzer",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/axlymxp~etsy-reviews-sentiment-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-axlymxp-etsy-reviews-sentiment-analyzer",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "shops": {
                        "title": "Shops to Analyze",
                        "type": "array",
                        "description": "Shop names, Etsy shop URLs, or numeric shop IDs to analyze.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search Query (alternative)",
                        "type": "string",
                        "description": "Instead of naming shops, discover shops to analyze by keyword."
                    },
                    "maxShops": {
                        "title": "Max Shops (for search query)",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum shops to analyze when using a search query.",
                        "default": 20
                    },
                    "maxReviewsPerShop": {
                        "title": "Max Reviews Per Shop",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How many recent reviews to analyze per shop.",
                        "default": 100
                    },
                    "emitReviews": {
                        "title": "Emit Individual Reviews",
                        "type": "boolean",
                        "description": "Also output one row per individual review with its sentiment label.",
                        "default": false
                    },
                    "language": {
                        "title": "Language Filter",
                        "type": "string",
                        "description": "Optional ISO language code to only analyze reviews in that language (e.g. 'en')."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
