# 🍾vivino wine review scraper⭐️ (`jordan-byte/vivino-wine-review-scraper`) Actor

extracts customer reviews from any wine page on [Vivino](https://www.vivino.com), the world's largest online wine marketplace and rating community.

- **URL**: https://apify.com/jordan-byte/vivino-wine-review-scraper.md
- **Developed by:** [Jordan Byte](https://apify.com/jordan-byte) (community)
- **Categories:** Automation, E-commerce, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.79 / 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

### What does Vivino Wine Review Scraper do?

**Vivino Wine Review Scraper** extracts customer reviews from any wine page on [Vivino](https://www.vivino.com), the world's largest online wine marketplace and rating community. Give it one or more wine page URLs and it returns each review's **rating, written note, reviewer, and date**, along with the wine's name, winery, vintage, region, and country. Try it instantly on the Apify platform — no coding required — or drive it through the [Apify API](https://docs.apify.com/api/v2) for scheduled runs and integrations with your own pipeline.

Running on Apify also means you get automatic **scheduling**, **monitoring and alerting** on failed runs, and one-click **integrations** with Zapier, Make, Google Sheets, Slack, and dozens of other tools — all without managing any infrastructure yourself.

### Why use Vivino Wine Review Scraper?

- **Market research** — track how a wine, vintage, or winery is being received by drinkers over time.
- **Competitive analysis** — compare ratings and sentiment across competing labels or vintages.
- **Sommelier & retail tools** — power a wine shop, app, or newsletter with fresh review data instead of stale static listings.
- **Sentiment & trend analysis** — feed review text into NLP or BI tools to spot recurring tasting notes and complaints.

### How to use Vivino Wine Review Scraper

1. Open a wine's page on [vivino.com](https://www.vivino.com) in your browser and copy the URL.
2. Paste it into the **Wine page URLs** field on the Input tab (add as many wines as you like).
3. Set **Max reviews per wine page** to control how many reviews to collect per wine.
4. Click **Start** and wait for the run to finish.
5. Download your results from the **Dataset** tab, or grab them via the API.

### Input

Configure the Actor on the **Input** tab in Apify Console, or by passing a JSON object via the API. The main fields are:

| Field | Type | Description |
| --- | --- | --- |
| `startUrls` | array | Vivino wine page URLs to collect reviews from. Include a vintage year in the URL (e.g. `?year=2018`) to limit results to that vintage. |
| `maxItems` | integer | Maximum number of reviews to collect per wine page URL. Defaults to `5`. |
| `reviewLanguage` | string | Two-letter language code to filter reviews by (e.g. `en`, `fr`, `de`). Defaults to `en`. |
| `proxyConfiguration` | object | Optional proxy settings. Disabled by default since Vivino wine pages generally don't require a proxy. |

Example input:

```json
{
    "startUrls": [
        { "url": "https://www.vivino.com/en/abreu-wines-cappella-red/w/3190767" }
    ],
    "maxItems": 20,
    "reviewLanguage": "en"
}
```

### Output

Each collected review is stored as one item in the dataset. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
    "reviewId": 311946310,
    "rating": 4.6,
    "reviewText": "High alcohol and young tannins almost hide a very great wine. Hoping to try more in the future.",
    "language": "en",
    "createdAt": "2024-08-08T08:25:37.000Z",
    "likesCount": 11,
    "commentsCount": 0,
    "reviewerName": "Ryan Hudson",
    "reviewerReviewsCount": 2403,
    "wineName": "Cappella Red",
    "wineryName": "Abreu",
    "vintageYear": 2018,
    "region": "Napa Valley",
    "country": "United States",
    "sourceUrl": "https://www.vivino.com/en/abreu-wines-cappella-red/w/3190767?year=2018"
}
```

#### Data table

| Field | Description |
| --- | --- |
| `reviewId` | Unique ID of the review |
| `rating` | Reviewer's rating, on Vivino's 1–5 scale |
| `reviewText` | The written review/tasting note |
| `language` | Language code the review was written in |
| `createdAt` | Date and time the review was posted |
| `likesCount` | Number of likes the review received |
| `commentsCount` | Number of comments on the review |
| `reviewerName` | Display name of the reviewer |
| `reviewerReviewsCount` | Total number of reviews the reviewer has posted on Vivino |
| `wineName` | Name of the wine |
| `wineryName` | Name of the winery |
| `vintageYear` | Vintage year the review refers to, if any |
| `region` | Wine region |
| `country` | Country of origin |
| `sourceUrl` | The wine page URL the review was collected from |

### Cost estimation

Vivino wine pages don't require a proxy or a browser to read, so this Actor is inexpensive to run. A run collecting 5 reviews for a single wine typically finishes in well under a minute and uses a fraction of a Compute Unit. Actual cost scales with the number of wine pages and reviews requested — use the **Max reviews per wine page** input to keep test runs quick and cheap, and raise it for full production runs.

### Tips for best results

- Keep **Max reviews per wine page** reasonable for testing; raise it once you've confirmed the fields you need.
- Add a vintage year to a wine page URL (e.g. `?year=2018`) to scrape only that vintage's reviews instead of reviews across all vintages.
- If you're scraping many wine pages, run the Actor on a schedule to keep review data fresh over time.

### FAQ, disclaimers, and support

This Actor collects publicly available review data from Vivino wine pages. It is intended for legitimate research, market analysis, and personal use. You are responsible for ensuring your use complies with Vivino's Terms of Service and applicable laws, including any restrictions on storing personal data such as reviewer names.

Ratings and review counts on Vivino change frequently as new reviews are posted, so results reflect a snapshot at the time of the run.

Found a bug or have a feature request? Open an issue on the Actor's **Issues** tab in Apify Console. Need a custom scraper or a modified version of this one? Reach out through the same tab to discuss a custom solution.

# Actor input Schema

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

One or more Vivino wine page URLs to collect reviews from. Copy the URL directly from your browser's address bar while viewing a wine on vivino.com. If the URL includes a vintage year (e.g. `?year=2018`), only reviews for that vintage are collected; otherwise reviews for all vintages of the wine are collected.

## `maxItems` (type: `integer`):

The maximum number of reviews to collect for each wine page URL provided above. Lower this to keep test runs quick and cheap.

## `reviewLanguage` (type: `string`):

Only collect reviews written in this language. Use a two-letter language code such as en, fr, de, it, es, or pt.

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

Configure proxies to route requests through. Vivino's wine pages generally do not require a proxy, so this is disabled by default to keep runs cheap. Enable it if you run into blocking.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.vivino.com/en/abreu-wines-cappella-red/w/3190767"
    }
  ],
  "maxItems": 5,
  "reviewLanguage": "en",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.vivino.com/en/abreu-wines-cappella-red/w/3190767"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jordan-byte/vivino-wine-review-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": [{ "url": "https://www.vivino.com/en/abreu-wines-cappella-red/w/3190767" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("jordan-byte/vivino-wine-review-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 '{
  "startUrls": [
    {
      "url": "https://www.vivino.com/en/abreu-wines-cappella-red/w/3190767"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call jordan-byte/vivino-wine-review-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jordan-byte/vivino-wine-review-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/RfWhuv894SJYY4kuz/builds/C6uGoQqeqQfLg69ka/openapi.json