# 🍷🍾vivino wine data scraper (`jordan-byte/vivino-wine-data-scraper`) Actor

Extract detailed wine product data from Vivino — names, wineries, regions, vintages, ratings, and prices — without writing a single line of scraping code

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

## Pricing

from $1.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

**Extract detailed wine product data from [Vivino](https://www.vivino.com) — names, wineries, regions, vintages, ratings, and prices — without writing a single line of scraping code.** Vivino Wine Product Scraper searches Vivino's wine catalog with the same filters (wine type, minimum rating, price range) available on the site, and returns clean, structured results ready for spreadsheets, price monitoring, or market research. Run it on-demand, on a schedule, or through the Apify API, with automatic proxy rotation and retries handled for you.

### Why use Vivino Wine Product Scraper?

Vivino is one of the largest wine marketplaces and rating communities in the world, but its catalog isn't built for bulk data collection. This Actor solves that by turning a simple set of filters into a ready-to-use dataset, so you can:

- **Monitor prices** for specific wine types or price brackets across merchants.
- **Research the market** by pulling top-rated wines in a region, style, or budget.
- **Build a wine catalog or comparison tool** without manually browsing hundreds of listings.
- **Track ratings trends** for wineries or wine styles over time by running the Actor on a schedule.

Because it runs on the Apify platform, you also get scheduling, webhooks, API access, and integrations with tools like Zapier, Make, and Google Sheets out of the box.

### How to use Vivino Wine Product Scraper

1. Click **Try for free** (or **Start**) to open the Actor.
2. On the **Input** tab, set your filters — wine type, minimum rating, price range, currency, and country. All fields have sensible defaults, so you can also just click **Start** to try it immediately.
3. Set **Max items** to control how many wine products the run should return.
4. Click **Start** and wait for the run to finish.
5. Open the **Storage** tab (or the **Output** tab) to view, filter, and export your results as JSON, CSV, Excel, HTML, or XML.

### Input

Vivino Wine Product Scraper is configured entirely through simple filters — no URLs or technical setup required. All fields are optional and have working defaults. See the **Input** tab for the full form, or provide a raw JSON object with the fields below.

| Field                             | Type    | Description                                                                                         |
| --------------------------------- | ------- | --------------------------------------------------------------------------------------------------- |
| `wineTypes`                       | array   | Wine types to include (Red, White, Sparkling, Rosé, Dessert, Fortified). Leave empty for all types. |
| `minRating`                       | number  | Minimum average rating, from 1.0 to 5.0. Default `3.5`.                                             |
| `priceRangeMin` / `priceRangeMax` | number  | Price range to filter results by, in the selected currency.                                         |
| `currencyCode`                    | string  | 3-letter currency code, e.g. `USD`, `EUR`, `GBP`.                                                   |
| `countryCode`                     | string  | 2-letter country code used to localize pricing and offers, e.g. `US`, `GB`, `DE`.                   |
| `language`                        | string  | Language code for wine names and descriptions, e.g. `en`, `fr`, `de`.                               |
| `orderBy` / `orderDirection`      | string  | Sort results by number of ratings, average rating, or price, ascending or descending.               |
| `maxItems`                        | integer | Maximum number of wine products to return in the run.                                               |
| `proxyConfiguration`              | object  | Proxy settings for the run. Apify Proxy is enabled by default for reliable results.                 |

Example input:

```json
{
    "wineTypes": ["1", "4"],
    "minRating": 4,
    "priceRangeMin": 10,
    "priceRangeMax": 75,
    "currencyCode": "USD",
    "countryCode": "US",
    "orderBy": "ratings_count",
    "orderDirection": "desc",
    "maxItems": 50
}
```

### Output

Each item in the dataset represents a single wine product. You can download results in JSON, CSV, Excel, HTML, XML, or RSS from the **Storage** tab.

```json
{
    "wineId": 1122095,
    "vintageId": 164942645,
    "name": "Moët & Chandon Impérial Brut Champagne",
    "vintageYear": "N.V.",
    "wineType": "Sparkling Wine",
    "winery": "Moët & Chandon",
    "region": "Champagne",
    "country": "France",
    "countryCode": "fr",
    "ratingsAverage": 4.1,
    "ratingsCount": 142715,
    "price": 39.99,
    "currency": "USD",
    "buyUrl": "https://example-merchant.com/product/moet-chandon-brut",
    "imageUrl": "https://images.vivino.com/thumbs/example.png",
    "productUrl": "https://www.vivino.com/w/1122095"
}
```

#### Data fields

| Field                                | Description                                                           |
| ------------------------------------ | --------------------------------------------------------------------- |
| `wineId` / `vintageId`               | Vivino's internal identifiers for the wine and this specific vintage. |
| `name`                               | Full display name of the wine, including winery and vintage.          |
| `vintageYear`                        | Vintage year, or `N.V.` for non-vintage wines.                        |
| `wineType`                           | Wine style: Red, White, Sparkling, Rosé, Dessert, or Fortified.       |
| `winery`                             | Producer/winery name.                                                 |
| `region` / `country` / `countryCode` | Wine origin.                                                          |
| `ratingsAverage` / `ratingsCount`    | Community rating (1-5) and number of ratings.                         |
| `price` / `currency`                 | Price and currency of the current offer, when available.              |
| `buyUrl`                             | Link to purchase the wine from the listed merchant.                   |
| `imageUrl`                           | Bottle/label image URL.                                               |
| `productUrl`                         | Link to the wine's page on Vivino.                                    |

### How much does it cost to scrape Vivino wine data?

Vivino Wine Product Scraper is efficient — each run fetches multiple wine products per request, so costs stay low even for larger result sets. On the [Apify Free plan](https://apify.com/pricing), you can comfortably run several hundred wine lookups per month at no cost. Actual usage depends on your `maxItems` setting and chosen proxy type; datacenter proxies (or no proxy) keep costs lowest, while residential proxies cost more but can improve reliability for large-scale or geo-specific runs.

### Tips for best results

- Start with a narrow `priceRangeMin`/`priceRangeMax` and a higher `minRating` to focus on premium picks, or widen both to build a broad catalog.
- Use `countryCode` and `currencyCode` together to get pricing and offers relevant to a specific market.
- If a run returns fewer results than expected, try lowering `minRating` or widening the price range — Vivino's catalog for very narrow filters can be limited.
- Combine `orderBy: "ratings_count"` with `orderDirection: "desc"` to prioritize well-established, frequently rated wines.

### FAQ

**Is it legal to scrape Vivino?**
Public wine listing data is generally considered fair to collect for personal research and analysis. This Actor only collects publicly visible product information. You are responsible for reviewing Vivino's Terms of Service and applicable laws before using the extracted data, especially for commercial purposes.

**Why don't I see a price for some wines?**
Not every wine on Vivino has an active merchant offer in every market. When no offer is available for the selected country and currency, `price` and `buyUrl` are returned as `null`.

**Can I get more fields, like tasting notes or grape varieties?**
Open an issue on the Actor's **Issues** tab with your request, or reach out — custom extraction and enrichment can be added on request.

**Found a bug or have a feature request?**
Please report it on the Actor's **Issues** tab so it can be investigated and fixed.

# Actor input Schema

## `wineTypes` (type: `array`):

Only return wines of the selected types. Leave empty to include every wine type.

## `minRating` (type: `number`):

Only return wines with an average rating equal to or higher than this value (1.0 - 5.0).

## `priceRangeMin` (type: `number`):

Only return wines priced at or above this amount, in the selected currency.

## `priceRangeMax` (type: `number`):

Only return wines priced at or below this amount, in the selected currency.

## `currencyCode` (type: `string`):

3-letter currency code used for prices and the price range filter, e.g. USD, EUR, GBP.

## `countryCode` (type: `string`):

2-letter country code used to localize pricing and available wine offers, e.g. US, GB, DE.

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

Language code for wine names and descriptions, e.g. en, fr, de.

## `orderBy` (type: `string`):

Field used to sort the results.

## `orderDirection` (type: `string`):

Whether results are sorted in ascending or descending order.

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

Maximum number of wine products to scrape in this run.

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

Proxy settings used for the requests. Apify Proxy is recommended for reliable results.

## Actor input object example

```json
{
  "wineTypes": [],
  "minRating": 3.5,
  "priceRangeMin": 0,
  "priceRangeMax": 150,
  "currencyCode": "USD",
  "countryCode": "US",
  "language": "en",
  "orderBy": "ratings_count",
  "orderDirection": "desc",
  "maxItems": 30,
  "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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("jordan-byte/vivino-wine-data-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("jordan-byte/vivino-wine-data-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 '{}' |
apify call jordan-byte/vivino-wine-data-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-data-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/X3La1BxqO5qNPFi0J/builds/hBqGxsjIvgQwUlFSE/openapi.json