# Feefo Scraper \[From $0.95💰] | Reviews | UK Merchant Data (`ahmed_jasarevic/feefo-scraper`) Actor

\[From $0.95💰] Extract verified Feefo reviews and ratings via the public Feefo API — no API key, no proxy, no Cloudflare bypass. Service & product reviews, reply threads, and aggregate merchant ratings for UK retailer reputation monitoring, competitor analysis, and review datasets.

- **URL**: https://apify.com/ahmed\_jasarevic/feefo-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.92 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Feefo Scraper: Extract Verified Feefo Reviews, Ratings & Merchant Data

Extract **verified Feefo reviews and ratings** from Feefo — the UK's leading purchaser-verified review platform, used by 6,500+ brands — via Feefo's **public Reviews API**. No API key, no proxy, no Cloudflare workaround. Pull service and product reviews, merchant reply threads, and aggregate rating summaries; a full Currys run (3.68M+ verified reviews) typically completes in under a minute.

### Main Use Cases

- **Competitor review monitoring for UK retailers and brands** — track rating changes, new feedback and merchant replies across any set of Feefo merchants
- **Reputation monitoring and customer experience management** — watch service review trends (delivery, would-buy-again, value for money) over time
- **E-commerce market research** — compare star distributions, verified counts and overall ratings across UK retailers
- **Product feedback datasets for sentiment analysis and NLP** — export SKU-level review text for e-commerce review analytics and model training
- **Building product review databases** — structured `product_title` / `product_sku` rows for catalog enrichment or product research

### How the Feefo Reviews Scraper Works

1. You provide one or more **Feefo merchant identifiers** — the slug in any Feefo review URL, e.g. `currys` in `feefo.com/reviews/currys`.
2. The actor calls Feefo's documented public JSON API (`https://api.feefo.com/api/20/reviews/...`), which requires **no authentication** for service, product and combined review modes.
3. It paginates through reviews (up to 100 per page), applies your filters (review mode, period, minimum rating, reply threads, per-merchant cap), and writes one flat JSON record per review to the dataset.
4. A per-merchant **summary record** (total/verified counts, star distribution, overall rating) is added when `includeSummary` is enabled.

### Why Use the Public Feefo API Instead of HTML Scraping

Feefo's public review pages are protected by bot detection, so page-scraping approaches need proxies and heavy anti-bot handling. This actor uses Feefo's own Reviews API — the same JSON endpoint that powers Feefo's widgets — which returns rich, structured data (verification states, service/product attributes, reply threads) with:

- **No API key, cookies, or sessions** for all / service / product modes
- **No proxy required** — `proxyConfiguration` is available but defaults to off
- Clean JSON that the actor **flattens into one record per review** for direct CSV/Excel/JSON export

### Configure Feefo Review Extraction Inputs

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `merchantIdentifiers` | `string[]` | Yes | `["currys"]` | Feefo merchant slug(s) — the part after `feefo.com/reviews/` |
| `reviewMode` | `string` | No | `"all"` | `"all"` (service + product), `"service"`, or `"product"` |
| `sincePeriod` | `string` | No | `"all"` | `"month"`, `"year"`, or `"all"` — review window |
| `includeFullThread` | `boolean` | No | `true` | Include merchant reply threads (`full_thread=include`) |
| `maxReviewsPerMerchant` | `integer` | No | `200` | Cap on pushed records per merchant; `0` = unlimited |
| `includeSummary` | `boolean` | No | `true` | Emit one aggregate summary record per merchant |
| `minRating` | `integer` | No | `1` | Only reviews with this rating **or higher** (1–5); e.g. `4` for 4–5 star focus |
| `proxyConfiguration` | `object` | No | `{"useApifyProxy": false}` | Available for edge cases — the API normally needs no proxy |

### Review and Summary Output Fields

Each review is a flat record (`_type: "review"`):

| Field | Type | Description |
|---|---|---|
| `_type` / `_review_type` | `string` | `"review"` / `"service"` or `"product"` |
| `merchant_identifier` | `string` | Feefo merchant slug |
| `review_id` / `review_url` | `string` | Feefo review UUID / public review URL |
| `customer_name` | `string` | Reviewer display name (e.g. "Nancy") |
| `rating` | `number` | Star rating 1–5 |
| `review_text` / `title` | `string` | Review comment (title only for service reviews) |
| `created_at` / `last_updated` | `string` | ISO-8601 timestamps |
| `helpful_votes` | `number` | Helpful votes |
| `verification_state` | `string` | e.g. `feefoVerified` |
| `locale` | `string` | e.g. `en_GB` |
| `service_attributes` | `object` | Delivery, would-buy-again, etc. (service reviews) |
| `product_attributes` | `object` | Value-for-money etc. (product reviews) |
| `products_purchased` | `string[]` | Purchased product names (service reviews) |
| `product_title` / `product_sku` / `product_url` | `string` | Product details (product reviews) |
| `merchant_reply` / `merchant_reply_date` | `string` | Merchant response (if `includeFullThread`) |
| `scraped_at` | `string` | When the record was fetched |

Each merchant also gets one aggregate record (`_type: "summary"`) with: `merchant_name`, `merchant_url`, `merchant_logo`, `merchant_review_url`, `merchant_address`, `total_reviews`, `verified_reviews`, `imported_reviews`, `rating_overall`, `rating_min/max`, star distributions `rating_service_1star...5star` and `rating_product_1star...5star`, and `scraped_at`.

### Example Input: Monitor a UK Retailer's Feefo Reviews

```json
{
  "merchantIdentifiers": ["currys", "appliances-direct"],
  "reviewMode": "all",
  "sincePeriod": "year",
  "includeFullThread": true,
  "maxReviewsPerMerchant": 200,
  "includeSummary": true,
  "minRating": 1
}
```

### Example Output: Real Currys Review Records

Record 1 — product review (`_review_type: "product"`):

```json
{
  "_type": "review",
  "_review_type": "product",
  "merchant_identifier": "currys",
  "review_id": "6aa17faae4b0d15eeec97735",
  "customer_name": "Nancy",
  "rating": 1,
  "review_text": "We have had a range of nespresso virtuo machines over the years and they have been great but the two up machines we've had have stopped working within a very short while...",
  "created_at": "2026-09-09T15:44:27.176Z",
  "verification_state": "feefoVerified",
  "locale": "en_GB",
  "product_title": "NESPRESSO by Krups Vertuo Up XN9404G0 Smart Pod Coffee Machine - Blue",
  "product_sku": "10301666",
  "product_attributes": {},
  "merchant_reply": null,
  "scraped_at": "2026-09-09T22:06:13.303Z"
}
```

Record 2 — merchant summary (`_type: "summary"`):

```json
{
  "_type": "summary",
  "merchant_identifier": "currys",
  "merchant_name": "Currys",
  "merchant_url": "https://www.currys.co.uk",
  "total_reviews": 3684654,
  "verified_reviews": 3684654,
  "rating_overall": 4.7,
  "rating_service_count": 3480389,
  "rating_service_5star": 3166328,
  "rating_product_count": 3686574,
  "rating_product_5star": 2567053,
  "scraped_at": "2026-09-09T22:06:10.182Z"
}
```

### Automate and Schedule Your Feefo Review Data Collection

- **API**: run the actor programmatically via the Apify REST API or `apify-client` (JavaScript / Python)
- **Scheduling**: schedule monthly, weekly or daily runs in Apify Console — daily for reputation monitoring, weekly for competitor benchmarking
- **Webhooks**: receive a push when a run finishes, then pipe new reviews into your BI stack
- **Zapier / Make**: connect to thousands of apps through Apify's integration hub
- **Exports**: download the dataset as JSON, CSV, or Excel at any time

### Related Actors for Customer Review Data Extraction

- [Google Maps Reviews Scraper](https://apify.com/compass/Google-Maps-Reviews-Scraper) — 56k+ users — extract Google Maps place reviews
- [Trustpilot All Reviews Scraper](https://apify.com/memo23/trustpilot-scraper-ppe) — export Trustpilot reviews past the web cap, with AI insights
- [Booking.com Review Scraper](https://apify.com/ahmed_jasarevic/booking-com-hotel-review-scraper) — hotel review and sentiment data
- [Vivino Wine Scraper](https://apify.com/ahmed_jasarevic/vivino-reviews-taste-profile-scraper) — wine ratings, prices and pairings
- [Google Play Reviews](https://apify.com/ahmed_jasarevic/google-play-reviews-scraper) — app reviews and ASO data

### FAQ: Feefo API and Review Data Questions

**Can I access Feefo reviews without an API key or Feefo account?**
Yes. Feefo's Reviews API requires no authentication for `all`, `service`, and `product` modes (only NPS mode requires credentials). This actor uses those public modes — no signup, no API key.

**How do I get review data out of Feefo to share with my team or build my own database?**
Feefo's own documentation points to the Reviews API for pulling review content and to dashboard exports for account holders. This actor automates the pull: give it merchant identifiers and it paginates, flattens, and exports every matching review to a dataset (JSON/CSV/Excel), including reply threads and aggregate summaries.

**Why use this actor instead of the official Feefo API?**
Three real reasons: (1) Feefo's docs warn the API is not intended as a batch-retrieval tool for self-hosting — this actor handles pagination, per-merchant caps, and multiple merchants in one run; (2) there is no official "download all reviews for any merchant" tool without account access — this works for any public merchant; (3) you get a ready dataset with webhooks and scheduling rather than having to build the pipeline yourself.

**Feefo vs Trustpilot — which platform's data is better for reputation monitoring?**
Feefo is a purchaser-verified-only platform (reviews come only from verified buyers), while Trustpilot is an open platform where anyone can post. For review data analytics, Feefo's verified-only data has fewer fake-review outliers. Use this actor for Feefo data, and pair it with a Trustpilot scraper for cross-platform benchmarking.

**Are Feefo reviews genuine / verified?**
Yes — Feefo only invites customers with proof of purchase (verified buyers); every record includes a `verification_state` (e.g. `feefoVerified`).

**Can I monitor a competitor's Feefo reviews?**
Yes. Enter any Feefo merchant slug in `merchantIdentifiers`; review pages and the API data are public. Schedule weekly runs for a competitor benchmark.

**Will this actor get blocked or need a proxy?**
No proxy is required — it uses Feefo's public JSON API, not HTML pages. A `proxyConfiguration` field exists for edge cases but defaults to off.

**How many reviews can I get per run?**
`maxReviewsPerMerchant` caps pushed records per merchant (0 = unlimited); the API returns up to 100 reviews per page and the actor paginates automatically. Note that the **free tier is capped at 10 records per run**.

### Competitive Positioning: Feefo API vs HTML-Based Scrapers

| Capability | HTML/URL-based Feefo scrapers | This actor |
|---|---|---|
| Data source | Scrape `feefo.com` review pages (proxies typical) | Feefo's documented public Reviews API |
| Proxy needed | Usually (`useApifyProxy: true`) | Not required (defaults off) |
| Pricing | e.g. rental plans (~$19/month) or ~$1.00 per 1,000 results | Pay-per-event, ~$0.0009 per result |
| Observed run success | Store-listed 31.3% runs succeeded (njoylab) | 3/3 development runs SUCCEEDED |
| Input | Page URL plus page/date/score controls | Merchant identifiers plus structured filters |

Comparison based on public Apify Store listings (njoylab/getdataforme/wibuild actor pages) and this actor's own run history, September 2026.

### For AI Agents & LLM Apps

**Purpose.** Returns flat JSON records of Feefo reviews (service and/or product) plus per-merchant aggregate rating summaries for any list of Feefo merchant identifiers, via Feefo's public API.

**Minimal working input.**

```json
{ "merchantIdentifiers": ["currys"], "maxReviewsPerMerchant": 50 }
```

**Variant — product-only reviews.**

```json
{ "merchantIdentifiers": ["currys"], "reviewMode": "product", "maxReviewsPerMerchant": 100 }
```

**Output fields (dataset items, `_type` distinguishes them).**
`review` records: `_review_type`, `merchant_identifier`, `review_id`, `review_url`, `customer_name`, `rating`, `review_text`, `title`, `created_at`, `last_updated`, `helpful_votes`, `verification_state`, `locale`, `service_attributes`, `product_attributes`, `products_purchased`, `product_title`, `product_sku`, `product_url`, `merchant_reply`, `merchant_reply_date`, `scraped_at`.
`summary` records: `merchant_name`, `merchant_url`, `merchant_logo`, `merchant_review_url`, `merchant_address`, `total_reviews`, `verified_reviews`, `imported_reviews`, `rating_overall`, `rating_service_*star`, `rating_product_*star`.

**Behaviors an agent should know.**

- `merchantIdentifiers` is the only required input; a review page URL will not work — pass the slug after `feefo.com/reviews/`.
- With the default `reviewMode: "all"`, one API review can produce **multiple dataset records** (one service + one per product) — size `maxItems` / billing expectations accordingly.
- `maxReviewsPerMerchant: 0` means unlimited per merchant — set an explicit cap for cost control (default 200).
- `minRating` is a floor ("rating or higher"), not an exact-value filter (e.g. `4` yields only 4–5 star reviews).
- `includeSummary: true` (default) adds one summary record per merchant before its reviews.
- Free-tier accounts get a hard cap of 10 records per run.

**Billing.** Pay-per-event: ~$0.0009 per dataset result (tier-dependent) plus a ~$0.0005 actor-start event. A 200-review single-merchant run costs roughly $0.18–$0.19.

### Legal & Compliance Disclaimer

This actor is an independent community tool and is **not affiliated with, endorsed by, or sponsored by Feefo Ltd**. It accesses only **publicly available data** through Feefo's documented public Reviews API — it performs no login bypass, no CAPTCHA solving, and uses no private or authenticated endpoints. Users are responsible for compliance with Feefo's Terms of Service and applicable data-protection law (including the UK GDPR, since records include reviewer display names). Extracted review data, including customer names, must not be used for unsolicited commercial outreach in violation of applicable law (e.g. CAN-SPAM, PECR / UK GDPR).

### SEO Keywords

feefo reviews, feefo api, feefo reviews api, feefo reviews scraper, scrape feefo reviews, feefo review data, feefo merchant reviews, currys reviews, uk retailer reviews, reviews api alternative, review monitoring software, competitor review analysis, ecommerce review analytics, product review dataset, review sentiment analysis, customer review data extraction, reviews.io alternative, trustpilot alternative, feefo vs trustpilot, verified reviews platform, merchant rating summary, product ratings api, review export api, reputation management data, uk ecommerce market research

# Actor input Schema

## `merchantIdentifiers` (type: `array`):

List of Feefo merchant identifiers to scrape. Find yours at https://www.feefo.com/reviews/<your-identifier> or in your Feefo Hub dashboard.

## `reviewMode` (type: `string`):

Which type of reviews to fetch: 'all' (service + product), 'service' only, or 'product' only.

## `sincePeriod` (type: `string`):

Time period for review aggregation: 'month', 'year', or 'all'.

## `includeFullThread` (type: `boolean`):

Include merchant reply threads in the output (increases response size slightly).

## `maxReviewsPerMerchant` (type: `integer`):

Maximum number of reviews to fetch per merchant (0 = all available). The API returns up to 100 per page.

## `includeSummary` (type: `boolean`):

Also output aggregate summary data (merchant info, total counts, star distribution) as a separate dataset item.

## `minRating` (type: `integer`):

Filter reviews to only include those with this rating or higher (1-5). Set to 0 or 1 for no filtering.

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

Proxy settings. The Feefo API rarely blocks, but proxy is available if needed.

## Actor input object example

```json
{
  "merchantIdentifiers": [
    "currys"
  ],
  "reviewMode": "all",
  "sincePeriod": "all",
  "includeFullThread": true,
  "maxReviewsPerMerchant": 200,
  "includeSummary": true,
  "minRating": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

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

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/feefo-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/NthQmQCqdbXo43UzC/builds/0j16bncH6ku5Kn5hX/openapi.json