# Vivino Wine Data Scraper (`automation-lab/vivino-wine-data-scraper`) Actor

🍷 Export public Vivino wine vintages, ratings, taste profiles, ranks, merchant prices, discounts, bottle details, and availability for analysis or monitoring.

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

## Pricing

Pay per event

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/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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Vivino Wine Data Scraper

Turn public Vivino pages into structured wine, vintage, rating, taste, rank, price, and merchant data.

Use the Actor for one wine lookup, a catalog export, or a scheduled price and reputation snapshot.

It accepts public Vivino listing, search, explore, and wine-detail URLs.

The output is ready for JSON, CSV, Excel, APIs, webhooks, data warehouses, and Apify integrations.

### What does Vivino Wine Data Scraper do?

Vivino Wine Data Scraper follows the URLs you provide and saves one dataset record per wine vintage or merchant offer.

It can:

- 🍷 identify wines, vintages, wineries, regions, and countries;
- ⭐ collect ratings, rating counts, review counts, and label counts;
- 🏆 capture global, country, region, winery, and wine-type ranks;
- 👃 extract taste structure, flavor groups, grapes, and food pairings;
- 💶 collect merchant prices, currencies, discounts, and bottle sizes;
- 📦 expose inventory and bottles-sold values when Vivino publishes them;
- 🔗 preserve canonical Vivino and merchant source URLs;
- 📅 produce repeatable snapshots for monitoring workflows.

The scraper reads anonymous server-rendered page data.

No Vivino account or private API key is required for public pages.

### Who is it for?

#### Wine retailers and distributors

Compare assortment, merchant prices, bottle formats, and visible inventory across selected catalogs.

#### Wineries and brand teams

Track rating volume, review volume, rank movement, taste positioning, and merchant availability for your wines.

#### Market researchers

Build structured samples by region, vintage, winery, style, grape, rating, or price.

#### Collectors and buyers

Export current offers for a shortlist instead of checking many product pages manually.

#### Data and BI teams

Feed normalized wine records into dashboards, databases, spreadsheets, and recurring alert pipelines.

### Why use this Vivino scraper?

Manual comparison is slow because wine identity, reputation signals, and merchant offers appear in different parts of a page.

This Actor flattens those signals into a consistent row shape.

Key benefits include:

- URL-first inputs that are easy to verify;
- one schema for direct detail and discovered listing results;
- stable vintage-and-price deduplication;
- typed numbers instead of formatted text;
- conservative request sequencing and retries;
- optional Apify Proxy configuration for geographic catalogs;
- explicit failure when every input yields no useful record.

### What Vivino data can you extract?

| Group | Fields |
|---|---|
| Wine identity | `wineId`, `wineName`, `wineType`, `style` |
| Vintage | `vintageId`, `vintageName`, `year` |
| Winery | `wineryId`, `wineryName` |
| Origin | `regionId`, `regionName`, `countryCode`, `countryName` |
| Reputation | `rating`, `ratingsCount`, `reviewsCount`, `labelsCount` |
| Taste | acidity, fizziness, intensity, sweetness, tannin, flavor groups |
| Pairing | `grapes`, `foodPairings` |
| Rankings | wine and vintage global/country/region/winery ranks |
| Top lists | `topListRank`, `topListName` |
| Offer | `priceId`, `price`, `discountedFrom`, `currency` |
| Bottle | bottle name, volume, inventory, bottles sold |
| Merchant | merchant ID, name, country, and destination URL |
| Traceability | image, canonical URL, source URL, scrape timestamp |

Fields are omitted when Vivino does not publish them for a particular wine or market.

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

The Actor uses pay-per-event pricing.

A run has a small start event and a result event for each dataset row.

The current source package uses:

- Actor start: **$0.005** per run;
- BRONZE wine-offer result: **$0.00014208** per saved row;
- lower per-row rates on higher Apify plans.

For example, a five-row BRONZE test is about **$0.00571** in Actor events, excluding your Apify platform usage.

The exact live prices appear in the Actor pricing tab and are authoritative.

Use a small `maxItems` value before scaling a new source URL.

### How to scrape Vivino in 4 steps

1. Open the Actor input page.
2. Add one or more public Vivino listing, search, explore, or wine-detail URLs.
3. Choose the maximum number of wine offers and listing pages.
4. Click **Start** and export the default dataset when the run finishes.

The prefilled example extracts a small set from one public wine detail URL.

### Input parameters

| Parameter | Type | Default | Purpose |
|---|---|---:|---|
| `startUrls` | array | required | Public Vivino sources to process |
| `maxItems` | integer | 5 | Maximum dataset rows |
| `maxPages` | integer | 2 | Maximum listing/search pages |
| `includeOffers` | boolean | true | Emit all visible merchant offers |
| `proxyConfiguration` | object | direct | Optional Apify Proxy routing |

`maxPages` applies to listing and search pagination.

Wine detail requests do not consume that page limit.

### Supported Vivino URLs

Supported inputs include:

- locale home or catalog pages such as `https://www.vivino.com/en/`;
- public search result URLs copied from Vivino;
- public explore URLs copied from Vivino;
- canonical wine paths containing `/w/<wine-id>`;
- vintage URLs with a `year` query parameter;
- offer URLs with a `price_id` query parameter.

Only `vivino.com` hosts are accepted.

External domains fail validation before scraping begins.

### Example input

```json
{
  "startUrls": [
    {
      "url": "https://www.vivino.com/en/it-s-cristina-lugana-lugana-white-wine-v/w/1127731?year=2024"
    }
  ],
  "maxItems": 5,
  "maxPages": 1,
  "includeOffers": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Set `includeOffers` to `false` when one representative vintage row is enough.

### Example output

```json
{
  "wineId": 1127731,
  "wineName": "Lugana",
  "vintageId": 179467428,
  "vintageName": "S. Cristina Lugana 2024",
  "year": 2024,
  "wineType": "White wine",
  "wineryName": "S. Cristina",
  "regionName": "Lugana",
  "countryName": "Italy",
  "rating": 4.1,
  "ratingsCount": 808,
  "reviewsCount": 170,
  "grapes": ["Turbiana"],
  "price": 16.5,
  "currency": "EUR",
  "merchantName": "Weinzeche Handelsgesellschaft mbH",
  "bottle": "Bottle (0.75l)",
  "canonicalUrl": "https://www.vivino.com/en/it-s-cristina-lugana-lugana-white-wine-v/w/1127731?year=2024",
  "scrapedAt": "2026-07-18T04:32:43.451Z"
}
```

Live values vary by visitor market and scrape time.

### Detail pages and merchant offers

A detail page may expose several merchants and several prices.

With `includeOffers: true`, the Actor emits a row for each unique vintage-and-price combination until `maxItems` is reached.

Wine-level fields repeat across those rows so each export row remains self-contained.

With `includeOffers: false`, the Actor emits one representative row for the vintage.

This makes the same Actor useful for both reputation datasets and price comparison datasets.

### Catalog and search workflows

Listing and search pages are discovery sources.

The Actor extracts public `/w/<id>` links, visits each detail page, and enriches it with structured vintage data.

Use a search URL when you want a narrow product universe.

Use a home or catalog URL for a broad sample.

Use explicit detail URLs for stable watchlists.

### Price and reputation monitoring

For recurring intelligence:

1. Save a task with a stable list of wine or catalog URLs.
2. Keep `maxItems` aligned with the expected catalog size.
3. Schedule the task daily or weekly.
4. Store each run in your warehouse or spreadsheet.
5. Compare `price`, `rating`, `ratingsCount`, ranks, and inventory over time.

The `scrapedAt` field identifies each observation time.

### Data quality and deduplication

Rows are deduplicated by vintage ID and price ID when those identifiers are available.

The Actor uses canonical detail URLs without offer-specific `price_id` parameters for stable comparison.

Numeric source values remain numbers.

Missing optional values are omitted rather than filled with invented defaults.

A run fails instead of reporting success with an empty dataset when no useful wine can be extracted.

### Tips for reliable runs

- Start with one known public detail URL.
- Keep the first run at five items or fewer.
- Copy complete URLs from your target Vivino locale.
- Use explicit detail URLs for critical watchlists.
- Increase `maxPages` only when the listing is paginated.
- Enable Apify Proxy if direct requests are blocked from your execution geography.
- Keep concurrency conservative when running many separate tasks.
- Recheck source coverage after Vivino redesigns a page.

### Apify integrations

#### Google Sheets

Send finished dataset rows to a sheet used by purchasing, sales, or category teams.

#### Webhooks

Trigger a downstream comparison job when a run succeeds.

#### Make

Schedule a task, filter changed prices, and route alerts to email or chat.

#### Zapier

Create lightweight notifications from new wine-offer rows.

#### Slack

Post rating milestones, newly visible merchants, or price decreases to a channel.

#### Data warehouses

Load datasets into BigQuery, Snowflake, PostgreSQL, or another analytical store.

### Run with the Apify API using Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/vivino-wine-data-scraper').call({
  startUrls: [
    { url: 'https://www.vivino.com/en/it-s-cristina-lugana-lugana-white-wine-v/w/1127731?year=2024' }
  ],
  maxItems: 5,
  maxPages: 1,
  includeOffers: true
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with the Apify API using Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('automation-lab/vivino-wine-data-scraper').call(run_input={
    'startUrls': [
        {'url': 'https://www.vivino.com/en/it-s-cristina-lugana-lugana-white-wine-v/w/1127731?year=2024'}
    ],
    'maxItems': 5,
    'maxPages': 1,
    'includeOffers': True,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### Run with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~vivino-wine-data-scraper/runs?token=$APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{
      "url": "https://www.vivino.com/en/it-s-cristina-lugana-lugana-white-wine-v/w/1127731?year=2024"
    }],
    "maxItems": 5,
    "maxPages": 1,
    "includeOffers": true
  }'
```

Fetch dataset items after the run finishes by using its `defaultDatasetId`.

### Use Vivino Wine Data Scraper with MCP

Connect the Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/vivino-wine-data-scraper"
```

For Claude Desktop, Cursor, or VS Code, add an HTTP MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/vivino-wine-data-scraper"
    }
  }
}
```

Example prompts:

- “Extract all visible offers for these five Vivino wine URLs.”
- “Compare merchant prices and bottle sizes in the returned dataset.”
- “Summarize rating, review-count, and global-rank differences.”
- “Create a CSV-ready list of wines under €20.”

### Export and storage formats

Apify datasets can be downloaded as:

- JSON;
- CSV;
- Excel;
- XML;
- RSS;
- JSONL.

Use the dataset API for incremental processing.

Use dataset views for a concise table of the most important wine and offer fields.

### Performance and memory

The Actor is HTTP-only and defaults to 256 MB of memory.

Requests run sequentially to reduce load and lower block risk.

A small direct-detail run normally completes well within the five-minute timeout.

Large listing jobs depend on page size, detail count, locale behavior, and remote response time.

### Proxy configuration

Direct HTTP is the default because public pages work anonymously in the validated route.

Enable Apify Proxy when:

- your execution IP receives a block page;
- you need a catalog localized to another market;
- repeated source requests are rate-limited.

Choose a country that matches the catalog you intend to observe.

Prices and merchants can differ by market.

### Is it legal to scrape Vivino?

This Actor extracts publicly available page data.

You are responsible for your use case, request volume, applicable law, contractual obligations, and Vivino terms.

Do not collect private account data.

Do not use the Actor to bypass authentication or access controls.

Apply appropriate retention and sharing rules to exported data.

When in doubt, obtain legal advice for your jurisdiction and workflow.

### Limitations

- Output reflects public data available to the run's market and time.
- Some wines have no current merchant offer.
- Optional taste, rank, inventory, or discount fields may be absent.
- The Actor does not log in to Vivino.
- The Actor does not submit reviews, purchases, or account actions.
- Search terms are supplied by copying a Vivino search URL, not as a separate keyword field.
- A major upstream redesign may require extractor maintenance.

### Troubleshooting

#### Why did my run return no records?

Confirm that every input is a public `vivino.com` listing, search, explore, or `/w/<id>` page.

Open the URL without signing in.

If it works in your browser but not in the Actor, enable Apify Proxy and choose the matching country.

The Actor intentionally fails a total extraction loss so empty monitoring runs are visible.

#### Why are merchant prices different from my browser?

Vivino can localize merchants, currencies, availability, and prices by country.

Use a proxy country that matches your comparison market and keep that country consistent between scheduled runs.

#### Why do several rows contain the same wine?

Each row represents a unique vintage or merchant offer.

Set `includeOffers` to `false` when you need one representative row per detail page.

#### Why is a taste or rank field missing?

Vivino does not publish every optional field for every wine and vintage.

The Actor omits unavailable fields rather than guessing values.

### Frequently asked questions

#### Can I scrape one wine?

Yes. Provide one detail URL and set `maxItems` to `1` if one representative row is sufficient.

#### Can I monitor a wine list?

Yes. Add several detail URLs to one task and schedule it.

#### Can I export to Excel?

Yes. Download the dataset in Excel format from the run page.

#### Does it scrape reviews text?

No. It captures rating and review-count signals, not individual review bodies.

#### Does it require residential proxy traffic?

Not by default. The validated public route works with direct HTTP, while proxy routing remains optional.

#### Can it scrape all 16 million wines?

The Actor is designed for bounded listings, search results, and explicit watchlists. Very large extraction plans should be split into controlled tasks with responsible request rates.

### Related scrapers

Combine this Actor with other public marketplace and review workflows:

- [Trip.com Hotel Reviews Scraper](https://apify.com/automation-lab/trip-com-hotel-reviews-scraper)
- [OpenTable Restaurants Reviews Scraper](https://apify.com/automation-lab/opentable-restaurants-reviews-scraper)
- [Mercado Libre Listing Scraper](https://apify.com/automation-lab/mercado-libre-listing-scraper)

All related links above point to automation-lab Actors.

### Support

If a public Vivino URL stops producing expected fields, open an Actor issue with:

- the exact input URL;
- the run ID;
- the expected field or record count;
- whether the page opens anonymously;
- the market or proxy country used.

That evidence makes source changes faster to reproduce and fix.

# Actor input Schema

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

Add one or more public vivino.com URLs. Listing/search pages are followed to their wine details.

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

Stop after this many wine vintage/merchant offer records.

## `maxPages` (type: `integer`):

Limit how many listing/search pagination pages are fetched. Wine detail pages do not count toward this limit.

## `includeOffers` (type: `boolean`):

Emit every merchant price found for each vintage. Disable to emit one representative vintage record.

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

Optional Apify Proxy routing for geographic catalogs or blocked execution IPs. Direct HTTP is used by default.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.vivino.com/en/it-s-cristina-lugana-lugana-white-wine-v/w/1127731?year=2024"
    }
  ],
  "maxItems": 5,
  "maxPages": 2,
  "includeOffers": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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/it-s-cristina-lugana-lugana-white-wine-v/w/1127731?year=2024"
        }
    ],
    "maxItems": 5,
    "maxPages": 2,
    "includeOffers": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "startUrls": [{ "url": "https://www.vivino.com/en/it-s-cristina-lugana-lugana-white-wine-v/w/1127731?year=2024" }],
    "maxItems": 5,
    "maxPages": 2,
    "includeOffers": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/vivino-wine-data-scraper").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 '{
  "startUrls": [
    {
      "url": "https://www.vivino.com/en/it-s-cristina-lugana-lugana-white-wine-v/w/1127731?year=2024"
    }
  ],
  "maxItems": 5,
  "maxPages": 2,
  "includeOffers": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/vivino-wine-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/vivino-wine-data-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vivino Wine Data Scraper",
        "description": "🍷 Export public Vivino wine vintages, ratings, taste profiles, ranks, merchant prices, discounts, bottle details, and availability for analysis or monitoring.",
        "version": "0.1",
        "x-build-id": "IUIBx4x76qbGMlGfv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~vivino-wine-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-vivino-wine-data-scraper",
                "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/automation-lab~vivino-wine-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-vivino-wine-data-scraper",
                "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/automation-lab~vivino-wine-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-vivino-wine-data-scraper",
                "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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Vivino URLs",
                        "type": "array",
                        "description": "Add one or more public vivino.com URLs. Listing/search pages are followed to their wine details.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum wine offers",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many wine vintage/merchant offer records.",
                        "default": 5
                    },
                    "maxPages": {
                        "title": "Maximum listing pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Limit how many listing/search pagination pages are fetched. Wine detail pages do not count toward this limit.",
                        "default": 2
                    },
                    "includeOffers": {
                        "title": "Include merchant offers",
                        "type": "boolean",
                        "description": "Emit every merchant price found for each vintage. Disable to emit one representative vintage record.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy routing for geographic catalogs or blocked execution IPs. Direct HTTP is used by default.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```