# Depop Reviews Scraper: Shop Reviews & Seller Ratings (`epicscrapers/depop-reviews-scraper`) Actor

Scrape Depop shop reviews in bulk: star rating, review text, date, reviewer and the reviewed item with price and photo. Add seller profiles with followers, rating and items sold. Paste shop URLs or usernames. No login. Export to JSON, CSV or Excel.

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

## Pricing

from $0.50 / 1,000 review saveds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Depop Reviews Scraper: shop reviews, ratings and seller profiles

Depop Reviews Scraper turns any Depop shop into a spreadsheet of its buyer reviews. For each review you get the star rating, the review text, the date, the reviewer and a snapshot of the item that was reviewed. It can also save one seller profile per shop, with bio, followers and rating. It is for resellers vetting a seller, brands and shops monitoring their own feedback, and researchers analyzing second-hand fashion.

- **Reviews with the reviewed item.** Each review includes the product's slug, URL, description, price, currency, status and image, so you can see what was sold.
- **Both sides of the transaction.** Collect reviews a shop received as a seller, as a buyer, or both.
- **Seller profiles on request.** `bio`, `country`, `followersCount`, `rating`, `reviewsTotal`, `sellerRatings`, `soldCount`, `lastSeen` and more, one row per shop.
- **Paste shop URLs, usernames or user IDs.** A mix works. Shop URLs and usernames are resolved to Depop user IDs for you.
- **Errors in the data, not in the log.** A shop that cannot be resolved or fails gets an `error` row, and the rest of the run continues. No Depop login needed. Export to JSON, CSV, Excel or Google Sheets.

**Scope:** This Actor collects reviews and seller profiles. It does not list a shop's products or search Depop. For other resale marketplaces, see the related Actors below.

### What can you do with Depop Reviews Scraper?

| Goal                               | How                                                                                                              |
| ---------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| Vet a seller before you buy        | Read the newest `rating` and `text` values, plus the seller profile's `rating`, `soldCount` and `sellerRatings`. |
| Summarize buyer feedback           | Export `text` and `rating` and group the themes, such as shipping speed or item condition.                       |
| Monitor your own shop              | Schedule a run and compare new `reviewId` values against the last run.                                           |
| Find what sells well               | Look at the reviewed `product` snapshots: `description`, `price`, `priceCurrency`.                               |
| Compare competing shops            | Add several shops and compare `rating` and `soldCount` from their `seller` rows.                                 |
| Check how a shop behaves as a buyer | Set `role` to `buyer` or `both`.                                                                                |

### How it compares

| What you need                  | Depop Reviews Scraper                           | Reading reviews in the app | Generic page scrapers      |
| ------------------------------ | ----------------------------------------------- | -------------------------- | -------------------------- |
| Review data                    | Structured: rating, text, date, reviewer, item  | One page at a time         | Depends on the setup       |
| Reviewed item details          | Included with each review                       | Tap through each review    | Often missing              |
| Several shops in one run       | Yes                                             | No                         | Yes                        |
| Seller and buyer reviews       | Either or both                                  | Separate screens           | Varies                     |
| Export                         | JSON, CSV, Excel, API                           | None                       | Yes                        |

### Quick start

1. Open the Actor and sign in to Apify.
2. Paste one or more Depop shop URLs into **Shop URLs**, for example `https://www.depop.com/nikerlina/`.
3. Keep the default limit of 100 reviews, or lower it for a first run.
4. Click **Start**, then open the **Output** tab and export the data.

```json
{
    "shopUrls": ["https://www.depop.com/nikerlina/"],
    "role": "seller",
    "maxReviews": 100,
    "includeSellerProfile": true
}
```

### Input

| Field                  | Type             | Default                  | Effect                                                                                           |
| ---------------------- | ---------------- | ------------------------ | ------------------------------------------------------------------------------------------------ |
| `shopUrls`             | Array of strings | Empty                    | Shop URLs such as `https://www.depop.com/nikerlina/`. `@username` URLs also work.                |
| `usernames`            | Array of strings | Empty                    | Depop usernames, instead of or together with URLs.                                               |
| `userIds`              | Array of strings | Empty                    | Numeric Depop user IDs. At least one of the three seller fields is required.                     |
| `role`                 | String           | `seller`                 | `seller` (reviews received as a seller), `buyer` (received as a buyer) or `both`.                |
| `maxReviews`           | Integer          | `100`                    | Newest reviews saved per shop and role. With `both`, the limit applies to each role.             |
| `pageLimit`            | Integer          | `30`                     | Reviews per request, 1 to 100. Lower it if you see rate limiting.                                |
| `includeSellerProfile` | Boolean          | `true`                   | Save one `seller` row per shop, for URLs, usernames and user IDs.                                |
| `country`              | String           | `GB`                     | Two-letter country code that Depop sees. The residential proxy uses the same country.            |

Shops are processed one after another, with a short pause between requests, so large lists take a while. Reviews of a shop given twice are scraped once.

### Output

Each dataset row has a `recordType`: `review`, `seller` or `error`.

A review row:

```json
{
    "recordType": "review",
    "reviewId": "3edafcc4583442bca49bde5a944fe812",
    "receiverId": 3138013,
    "receiverUsername": "nikerlina",
    "shopUrl": "https://www.depop.com/nikerlina/",
    "reviewerId": 1110252,
    "reviewerUsername": "fitzhannah",
    "role": "seller",
    "rating": 5,
    "text": "Quick delivery and item arrived in perfect condition as described. Thank you!",
    "date": "2026-01-02T17:03:07.43019Z",
    "transactionId": 251760586,
    "productId": 587980001,
    "product": {
        "id": 587980001,
        "slug": "nikerlina-motel-brown-and-white-gingham",
        "productUrl": "https://www.depop.com/products/nikerlina-motel-brown-and-white-gingham/",
        "description": "Motel gingham skirt",
        "brandId": 296,
        "price": "12.00",
        "priceCurrency": "GBP",
        "status": "P",
        "imageUrl": "https://media-photos.depop.com/x/P5.jpg"
    },
    "reviewer": {
        "id": 1110252,
        "username": "fitzhannah",
        "country": "GB",
        "pictureUrl": null
    },
    "scrapedAt": "2026-09-16T17:30:00.000Z"
}
```

A seller row has `userId`, `username`, `shopUrl`, `firstName`, `lastName`, `verified`, `bio`, `website`, `country`, `followersCount`, `followingCount`, `rating` (average stars), `reviewsTotal`, `sellerRatings` and `buyerRatings` (review counts per role), `soldCount`, `lastSeen`, `pictureUrl` and `scrapedAt`.

An error row has `shopUrl`, `username` or `userId`, an `error` message and `scrapedAt`.

#### Notes on fields

- `role` on a review row tells you whether the shop received it as a seller or as a buyer.
- `rating` is 1 to 5. `date` is an ISO timestamp.
- `product` is the item as it looked at scrape time. `price` is a string and `priceCurrency` is its currency. `status` is Depop's own status code. The product can be missing or `null` if Depop did not return it.
- `reviewerUsername` and `reviewer` can be `null` if Depop did not return the reviewer.
- Seller rows are saved when the shop is resolved, before its reviews. Rows are not sorted by shop.
- Depop leaves some reviews out of its review list (for example, reviews of deleted items), so a shop can return fewer review rows than its `sellerRatings` or `buyerRatings` count.
- Missing values are `null`.

### Track Depop shop reviews over time with scheduled runs

Reviews and seller stats keep growing. Apify can run the actor on a schedule and send the results wherever you need them.

#### 1. Save your input as a task

Open the actor, add your shops and options, then click **Save as a new task**. A task is a saved input you can run again with one click or on a schedule.

#### 2. Schedule the task

In Apify Console, go to **Schedules**, click **Create new**, choose how often to run (for example daily at 06:00 in your time zone), and add your task. See [Schedules](https://docs.apify.com/platform/schedules) and [How to create a schedule](https://help.apify.com/en/articles/7120817-how-to-create-a-schedule).

Watch how to schedule an Actor:

https://www.youtube.com/watch?v=1jI7WcVQmwM

Or schedule a saved task:

https://www.youtube.com/watch?v=GRFW_Loo2dk

Common schedules:

| Use case | Frequency | Cron expression |
| --- | --- | --- |
| New reviews on your own shop | Daily | `0 6 * * *` |
| Competitor monitoring | Weekly (Monday) | `0 6 * * 1` |
| Seller stats snapshots | Weekly (Sunday) | `0 0 * * 0` |
| Reputation alerts during sales peaks | Twice a day | `0 6,18 * * *` |

#### 3. Send the results to a spreadsheet

Connect Google in the task's **Integrations** tab to save every run to Google Sheets or Google Drive automatically:

https://www.youtube.com/watch?v=IFTeKdj6ZGM

#### 4. Compare runs

Review rows have `reviewId` and `date`, and seller rows have `userId` and `scrapedAt`, so runs are easy to join:

- **New reviews:** `reviewId`s you have not seen before, sorted by `date`.
- **Rating trend:** average `rating` per `receiverUsername` over time.
- **Negative feedback:** reviews with `rating` of 2 or lower, with their `text` and `productId`.
- **Seller growth:** `followersCount`, `soldCount` and `reviewsTotal` from the seller rows, per `userId`.
- **Failures:** rows with `recordType` `error` show which shops to check.

### For AI agents

Call `epicscrapers/depop-reviews-scraper` with:

```json
{ "shopUrls": ["https://www.depop.com/nikerlina/"], "maxReviews": 50, "role": "seller", "includeSellerProfile": true }
```

Each dataset row has a `recordType`:

- `review`: `reviewId`, `rating` (1 to 5), `text`, `date`, `reviewerUsername`, `receiverUsername`, `role`, `product.productUrl`, `product.price`, `product.priceCurrency`.
- `seller`: `username`, `followersCount`, `rating`, `reviewsTotal`, `sellerRatings`, `soldCount`, `country`.
- `error`: `error` explains why a shop failed. Other shops still run.

`usernames` (for example `["nikerlina"]`) and `userIds` (for example `["3138013"]`) work instead of `shopUrls`.

### FAQ

#### How many reviews can I get?

Set `maxReviews`, which is applied per shop and per role. The Actor pages through a shop's reviews, newest first, until it reaches the limit or runs out. A shop with fewer reviews than the limit returns every review Depop lists, which can be fewer than the count on its profile.

#### Why did a shop give an error row?

The URL may not be a shop URL (product and other pages do not work), the username may not exist, or Depop may have blocked the request. The `error` field says which. Other shops in the run are not affected.

#### Do I need a Depop account or an API key?

No. The Actor does not log in.

#### Do I need my own proxy?

No. Every run uses residential Apify Proxy in the `country` you set, and the proxy cost is included in the price. Depop blocks datacenter IPs, so there is no proxy setting to get wrong.

#### Why is it slow for many shops?

Shops are processed one at a time, with a pause of about 0.7 seconds between requests and retries if Depop rate limits. Lower `pageLimit` only if you see rate limiting. A larger one needs fewer requests.

#### Is it legal to scrape Depop reviews?

The Actor collects reviews that are public on Depop shops. You are responsible for how you use the data, including Depop's terms and laws such as GDPR, since reviews name the reviewer.

### Cost

You pay per result. Platform usage and residential proxy are included.

| Event | Price |
| --- | --- |
| Review saved | $0.50 per 1,000 reviews |
| Seller profile saved | $0.002 per shop (only with `includeSellerProfile`) |
| Actor start | $0.00005 |
| Error rows | Free |

Example: 100 reviews from each of 10 shops, with seller profiles, costs 1,000 × $0.0005 + 10 × $0.002 = $0.52.

Set a maximum cost per run in Apify Console or with `maxTotalChargeUsd` in the API. The run stops cleanly when it reaches the limit, and you are not charged past it.

### Related Actors

- [Vinted Search Scraper](https://apify.com/epicscrapers/vinted-search-scraper): second-hand fashion listings on Vinted.
- [Wallapop Seller Scraper](https://apify.com/epicscrapers/wallapop-seller-scraper): sellers and their items on Wallapop.
- [eBay Reviews Scraper](https://apify.com/epicscrapers/ebay-reviews-scraper): seller feedback on eBay.
- [Etsy Shop Scraper](https://apify.com/epicscrapers/etsy-shop-scraper): shop profiles and reviews on Etsy.

### Support

Report problems or request features through the Issues tab or to the Actor's owner. Include the run ID, your input and what you expected.

This Actor is not affiliated with or endorsed by Depop. "Depop" is a trademark of its owner.

# Actor input Schema

## `shopUrls` (type: `array`):

Paste Depop shop page URLs. The Actor automatically resolves each URL to the internal Depop user ID. Example: <code>https://www.depop.com/nikerlina/</code>

## `usernames` (type: `array`):

Use this only if you already know the Depop usernames. Can be used instead of URLs or together with them. Example: <code>nikerlina</code>

## `userIds` (type: `array`):

Use this only if you already know the numeric Depop user IDs. Example: <code>3138013</code>

## `role` (type: `string`):

Which side of the transaction to scrape: reviews the seller <code>received</code> as a seller, as a <code>buyer</code>, or <code>both</code>.

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

Maximum number of newest reviews to save for each seller and role. Increase this when you need deeper history; keep it low for quick tests and lower costs.

## `pageLimit` (type: `integer`):

Page size for each API request. Lower this if you see rate limiting.

## `includeSellerProfile` (type: `boolean`):

Save one <code>seller</code> record per shop with bio, country, follower counts, ratings, items sold and avatar. Works for shop URLs, usernames and user IDs.

## `country` (type: `string`):

Two-letter country code sent as <code>X-Country-Code</code> (e.g. <code>GB</code>, <code>US</code>). The residential proxy uses the same country.

## Actor input object example

```json
{
  "shopUrls": [
    "https://www.depop.com/nikerlina/"
  ],
  "usernames": [],
  "userIds": [],
  "role": "seller",
  "maxReviews": 100,
  "pageLimit": 30,
  "includeSellerProfile": true,
  "country": "GB"
}
```

# Actor output Schema

## `results` (type: `string`):

Default dataset containing review records, optional seller profile records, and error records.

# 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 = {
    "shopUrls": [
        "https://www.depop.com/nikerlina/"
    ],
    "usernames": [],
    "userIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/depop-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 = {
    "shopUrls": ["https://www.depop.com/nikerlina/"],
    "usernames": [],
    "userIds": [],
}

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

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

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

```

## CLI example

```bash
echo '{
  "shopUrls": [
    "https://www.depop.com/nikerlina/"
  ],
  "usernames": [],
  "userIds": []
}' |
apify call epicscrapers/depop-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,epicscrapers/depop-reviews-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/U3tm3Cin1ntynYrDI/builds/ybJoSD2N5ZmKYa7Vu/openapi.json