# Wine-Searcher scraper by grape variety: prices (`mrbridge/wine-searcher-grape-scraper`) Actor

Scrape Wine-Searcher's 1,054 grape variety pages, from Pinot Noir to obscure indigenous grapes. Get popularity, critic scores and prices with auto-detected currency, plus product names, regions and countries. Export, schedule, or pipe into Zapier, Make, and n8n. By MrBridge (mr-bridge.com)

- **URL**: https://apify.com/mrbridge/wine-searcher-grape-scraper.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 18 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 1,000 wine result extracteds

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

## Wine-Searcher Grape Scraper: popularity, scores & prices

Extract wine data from [Wine-Searcher](https://www.wine-searcher.com) grape variety pages at scale. This Actor scrapes popularity, critic scores, and average prices for every wine listed under a grape, plus product names, regions, and countries, from canonical varieties like Pinot Noir or Cabernet Sauvignon down to obscure indigenous grapes like Voskehat or Xynomavro. Pick a grape from a dropdown of 1,054 varieties, paste a Wine-Searcher grape URL, or flip one switch to crawl every grape on the site.

**No Wine-Searcher subscription needed, no API key, no coding.** Just pick a grape and click Start.

### Features

- **One row per wine** with product name, listing link, region, region link, country, popularity rank, critics' score, average price and currency.
- **1,054 grape varieties** in a dropdown, or any `grape-{id}-{slug}` page through `customUrl`, or every grape in one run with `scrapeAllGrapes`.
- **Five sort tabs**: Most Popular, Best Rated, Best Value, Most Expensive, Cheapest.
- **Pagination built in**: up to 50 pages per grape (about 1,250 wines), stopping at the first page that adds no new wine.
- **Optional currency conversion** to 30 ISO codes with a live exchange rate, next to the original `avg_price`.
- **Each wine delivered and billed once**: duplicates are dropped, and the run stops as soon as your maximum cost or your `maxWines` cap is reached.
- **Failures are visible, never billed**: a page that cannot be fetched becomes a free error row, and five failures in a row stop the run with a clear status.
- **Run summary and quality check**: an `OUTPUT` record with the counters, and a log warning when a field turns mostly empty.
- **Export** to JSON, CSV or Excel, or call it through the Apify API, schedules and webhooks.

### What does Wine-Searcher Grape Scraper do?

Wine-Searcher is the world's largest wine search engine, indexing over 18 million wines from 120,000+ merchants. This scraper extracts structured data from Wine-Searcher's **grape variety pages**, which rank wines by popularity, ratings, value, or price within any single grape (or grape blend).

For each wine found, the scraper extracts:

- **Product name** and direct link to the Wine-Searcher listing
- **Region** and **country** of the wine, plus the link to the region page
- **Popularity ranking** within the grape's listing
- **Critics' score** (average across professional reviewers, out of 100)
- **Average price** per 750ml bottle in US dollars, with optional conversion to 30 currencies
- **Bottle label image** URL when Wine-Searcher shows one
- **Source grape** (the grape page that was scraped, e.g. "Pinot Noir") and **`source_grape_id`** (Wine-Searcher's internal numeric ID, e.g. `384`)

The scraper handles pagination automatically (up to 50 pages × ~25 wines = 1,250 wines per grape) and can sweep every one of Wine-Searcher's 1,054 grape varieties in a single run via `scrapeAllGrapes`.

### Which wine scraper should I use?

| Need | Best scraper | What it does |
|------|-----------|-------------|
| Grape popularity, scores & prices | **Wine-Searcher Grape Scraper** (this one) | Popularity, critic scores & prices by grape variety on Wine-Searcher |
| Look up specific wines by name, URL or LWIN | [Wine-Searcher Scraper from List](https://apify.com/mrbridge/wine-searcher-scraper-from-list) | Critic scores, cheapest prices, winery info & popularity for each wine |
| Critic ratings (Parker, Spectator, Decanter...) | [Millesima Wine Scraper](https://apify.com/mrbridge/millesima-wine-scraper) | Prices + scores from 18 major critics |
| Community ratings & taste profiles | [Vivino Wine Scraper](https://apify.com/mrbridge/vivino-powerful-scraper) | Browse Vivino wines by region |
| Look up specific wines by name/URL | [Vivino Wine Data Scraper](https://apify.com/mrbridge/vivino-wine-data-scraper) | Search Vivino by wine name or URL |

### Why scrape Wine-Searcher grape data?

Grape-level data lets you compare prices, ratings, and popularity across regions and producers. Use cases:

- **Importers and distributors**: benchmark a producer's pricing against the global Pinot Noir or Chardonnay distribution before negotiating allocation.
- **Sommeliers and wine buyers**: build varietal sections of a wine list driven by data: top-rated Riesling under $40, best-value Nebbiolo, the 25 most popular Sauvignon Blancs of the year.
- **Ampelographic research**: collect comparable price/rating signals across regional expressions of the same grape (Syrah vs Shiraz, Tempranillo across Rioja, Ribera del Duero, Toro).
- **Wine investors and collectors**: identify rising grape categories (Assyrtiko, Xinomavro, Mencía) before they hit mainstream price brackets.
- **E-commerce platforms and wine clubs**: enrich product catalogs with grape-level critics' scores, rankings, and average market prices.

### How to use Wine-Searcher Grape Scraper in 60 seconds

1. Click **"Try for free"** to open this actor in Apify Console
2. The default input scrapes **Pinot Noir**. Leave it or pick any of 1,054 grapes from the dropdown.
3. Click **"Start"**
4. Download your results from the **Dataset** tab (JSON, CSV, Excel)

That's it! No Wine-Searcher subscription needed, no API key, no coding. The full input reference (grape dropdown, `customUrl` override, `scrapeAllGrapes` sweep, pagination, sort, currency conversion) is detailed in **How do I configure the scraper?** below.

### What data can you extract?

| Field | Description | Example |
|-------|-------------|---------|
| `product_name` | Full wine name with producer and origin | "Domaine de la Romanee-Conti Romanee-Conti Grand Cru" |
| `product_url` | Direct link to the wine on Wine-Searcher | `https://www.wine-searcher.com/find/...` |
| `region` | Wine region shown in the listing row | "Cote de Nuits" |
| `region_url` | Link to the region page (null when the row carries no region link) | `https://www.wine-searcher.com/regions-cote-de-nuits` |
| `country` | Country slug read from the row's flag icon (empty when absent) | "france" |
| `label_image_url` | Bottle label thumbnail URL (null when absent) | `https://www.wine-searcher.com/images/labels/...` |
| `popularity` | Popularity ranking within the grape page | "12th in popularity" |
| `critics_score` | Average score from professional critics | "98 / 100" |
| `avg_price` | Average price per 750ml bottle | "$ 24,099" |
| `currency` | ISO code of the currency detected on the row, USD in practice | "USD" |
| `avg_price_converted` | Price converted to your target currency (null if disabled) | 22150.45 |
| `target_currency` | ISO code of the target currency (empty if disabled) | "EUR" |
| `source_grape` | Grape page name that produced the row | "Pinot Noir" |
| `source_grape_id` | Wine-Searcher numeric ID of that grape page | "384" |
| `source_url` | The grape page URL that was scraped | `https://www.wine-searcher.com/grape-384-pinot-noir?tab_F=mostpopular` |

> **Note on `region` vs. `source_grape`**: `region` describes the wine itself (the region column of the listing row, e.g. "Cote de Nuits"), while `source_grape` always names the grape page the row was scraped from ("Pinot Noir"). This distinction matters when joining data across grape pages. Wine-Searcher relabelled that column from "Grape" to "Region" in 2026-05, which is why the fields are named `region` / `region_url` since v2.2.0 (they were `grape` / `grape_url` up to v2.1).

#### Supported currencies

Every page is fetched through a US connection, so Wine-Searcher shows its prices in US dollars and `avg_price` is in USD. The `currency` field still records the currency detected on each row, which lets you check it. Set `targetCurrency` to convert every price to one of the 30 most-traded ISO codes with a live exchange rate.

### More wine data tools

- [Vivino MCP server for wine pairing](https://apify.com/mrbridge/vivino-mcp-server): ask Claude or ChatGPT for wines by rating, price or style, and get pairing ideas for a meal or a budget.
- [Vivino data scraper](https://apify.com/mrbridge/vivino-wine-data-scraper): ratings, prices, taste profiles and reviews for a list of wines, by name or by Vivino URL.
- [Vivino scraper by region](https://apify.com/mrbridge/vivino-powerful-scraper): every wine of a Vivino region or producer page, with ratings, prices, vintages and taste profiles.
- [Wine-Searcher API for a wine list](https://apify.com/mrbridge/wine-searcher-scraper-from-list): critic scores, cheapest prices and merchants for your own list of wines and spirits.
- [Wine-Searcher scraper by region](https://apify.com/mrbridge/wine-searcher-region-scraper): popularity rank, critic score and average price for the wines of a region or appellation.
- [Millesima prices and critic scores](https://apify.com/mrbridge/millesima-wine-scraper): Bordeaux and Burgundy prices per bottle and per case, with critic ratings from 18 publications.

This Actor is part of the **MrBridge** wine toolkit - see the [Wine-Searcher region scraper](https://mr-bridge.com/solutions/wine-searcher-region-scraper) page, the [Wine-Searcher grape scraper](https://mr-bridge.com/solutions/wine-searcher-grape-scraper) page or [browse all scrapers](https://mr-bridge.com/scrapers). Related analysis: [Burgundy vs Bordeaux: a price comparison](https://mr-bridge.com/studies/burgundy-vs-bordeaux-price-comparison).

### How do I configure the scraper?

Three precedence-ordered ways to specify the target:

1. **Dropdown** (`grape`): 1,054 grape varieties baked from Wine-Searcher's official index. Default: Pinot Noir. Each entry maps to `https://www.wine-searcher.com/grape-{id}-{slug}`.
2. **Custom URL** (`customUrl`): paste any Wine-Searcher grape URL. This overrides the dropdown. Useful for brand-new grapes not yet baked. Pattern: `^https://www\.wine-searcher\.com/grape-\d+-[a-zA-Z0-9%+\-]+`.
3. **Scrape all** (`scrapeAllGrapes`): tick to ignore both fields and walk all 1,054 grapes. Pair with low `maxPagesPerGrape` (1–3) to keep cost predictable.

#### Full input reference

| Parameter | Type | Console prefill | Description |
|-----------|------|-----------------|-------------|
| `grape` | dropdown · 1,054 grapes | Pinot Noir | Grape variety selector (Wine-Searcher's full official grape index) |
| `customUrl` | textfield (URL) | - | Optional override for grape pages not in the dropdown (must match the `grape-{id}-{slug}` pattern) |
| `scrapeAllGrapes` | checkbox | `false` | Ignore the dropdown and crawl every grape variety on Wine-Searcher |
| `maxPagesPerGrape` | integer | `3` | Pages per grape (~25 wines/page, range 1–50) |
| `maxWines` | integer | `1000` | Soft cap on the total number of wines across all grapes. `0` means unlimited (only your Apify spending limit applies) |
| `tabFilter` | dropdown · 5 options | `Most Popular` | Sort: Most Popular, Best Rated, Best Value, Most Expensive, Cheapest |
| `targetCurrency` | dropdown · 30 currencies | (none) | Optional ISO code to convert the USD prices with a live exchange rate |

> Numeric defaults shown above are the **Console prefills**. Programmatic API callers that omit `maxPagesPerGrape` entirely fall back to the schema default of `5`.

Proxies, timeouts, and anti-bot handling are managed automatically. No configuration needed.

#### Example: default, top Pinot Noir wines

```json
{
    "grape": "https://www.wine-searcher.com/grape-384-pinot-noir",
    "maxPagesPerGrape": 3,
    "tabFilter": "mostpopular"
}
```

#### Example: Top-rated Nebbiolo via `customUrl` override

```json
{
    "customUrl": "https://www.wine-searcher.com/grape-316-nebbiolo",
    "maxPagesPerGrape": 5,
    "tabFilter": "best"
}
```

#### Example: Sweep every grape on Wine-Searcher

```json
{
    "scrapeAllGrapes": true,
    "maxPagesPerGrape": 3,
    "tabFilter": "mostpopular"
}
```

### Output example

![Sample output of Wine-Searcher Grape Scraper: product name, region, country, popularity rank, critics score and average price in USD for the most popular Pinot Noir wines](https://api.apify.com/v2/key-value-stores/5gTeWNmoJiKNnfYoz/records/wine-searcher-grape-scraper-output.png)

```json
{
    "product_name": "Domaine de la Romanee-Conti Romanee-Conti Grand Cru, Cote de Nuits, France",
    "product_url": "https://www.wine-searcher.com/find/domaine+romanee+conti+grand+cru+cote+nuits+france",
    "region": "Cote de Nuits",
    "region_url": "https://www.wine-searcher.com/regions-cote-de-nuits",
    "country": "france",
    "label_image_url": "https://www.wine-searcher.com/images/labels/12/34/example-label.jpg",
    "popularity": "1st in popularity",
    "critics_score": "98 / 100",
    "avg_price": "$ 24,099",
    "currency": "USD",
    "avg_price_converted": 22150.45,
    "target_currency": "EUR",
    "source_grape": "Pinot Noir",
    "source_grape_id": "384",
    "source_url": "https://www.wine-searcher.com/grape-384-pinot-noir?tab_F=mostpopular"
}
```

### How much does it cost?

Wine-Searcher Grape Scraper uses **pay-per-event** pricing. Each wine successfully saved to the dataset triggers one `wine-result` event. Page fetch failures, diagnostic error rows, empty pages, and circuit-breaker sentinels do not trigger that event.

See the [Pricing tab](https://apify.com/mrbridge/wine-searcher-grape-scraper/pricing) for the current rate for your subscription tier, automatic discounts, and any platform-managed events. You can set a maximum cost per run in Apify Console.

**Memory**: 512 MB is the default and is sufficient for normal runs. Since v2.0 the Actor runs no browser and processes one page at a time. Users can select up to 2048 MB for unusual workloads, but increasing memory is normally unnecessary.

### Which grapes can I scrape?

Any of the 1,054 grape varieties in Wine-Searcher's official grape index. The 15 **featured grapes** below are the highest-volume targets and a sensible starting point:

| Grape | URL |
|-------|-----|
| Bordeaux Blend Red | `https://www.wine-searcher.com/grape-3-bordeaux-blend-red` |
| Cabernet Sauvignon | `https://www.wine-searcher.com/grape-76-cabernet-sauvignon` |
| Chardonnay | `https://www.wine-searcher.com/grape-98-chardonnay` |
| Chenin Blanc | `https://www.wine-searcher.com/grape-102-chenin-blanc` |
| Gewurztraminer | `https://www.wine-searcher.com/grape-187-gewurztraminer` |
| Malbec | `https://www.wine-searcher.com/grape-261-malbec` |
| Merlot | `https://www.wine-searcher.com/grape-275-merlot` |
| Nebbiolo | `https://www.wine-searcher.com/grape-316-nebbiolo` |
| Pinot Gris/Grigio | `https://www.wine-searcher.com/grape-382-pinot-grisgrigio` |
| Pinot Noir | `https://www.wine-searcher.com/grape-384-pinot-noir` |
| Riesling | `https://www.wine-searcher.com/grape-407-riesling` |
| Sangiovese | `https://www.wine-searcher.com/grape-432-sangiovese` |
| Sauvignon Blanc | `https://www.wine-searcher.com/grape-435-sauvignon-blanc` |
| Shiraz and Syrah | `https://www.wine-searcher.com/grape-1112-shiraz-and-syrah` |
| Tempranillo | `https://www.wine-searcher.com/grape-483-tempranillo` |

Beyond featured grapes, the dropdown covers the full long tail: Albariño, Assyrtiko, Carmenère, Furmint, Grenache, Lagrein, Mencía, Petit Verdot, Touriga Nacional, Verdejo, Vermentino, Viognier, Xinomavro, Zinfandel, and ~1,000 more.

### Tips for best results

1. **Start small**: Test with a single grape and `maxPagesPerGrape: 1` to verify the output format before running a full sweep.
2. **Use `scrapeAllGrapes` carefully**: with 1,054 grapes × even just 3 pages each, you can comfortably exceed 5,000 wines, and every wine saved is one billed event. Lower `maxPagesPerGrape` to 1 for a wide-but-shallow sweep, and keep `maxWines` at a value you are happy to pay for. The run stops as soon as that cap is reached.
3. **Use sorting wisely**: "Most Popular" returns the widest market sample; "Best Rated" surfaces critic favourites; "Best Value" finds bargains; "Most Expensive" / "Cheapest" anchor each end of the price ladder.
4. **Pick your currency once**: prices arrive in US dollars. Set `targetCurrency` if you want them in EUR, GBP or another of the 30 codes, and every row comes back converted.
5. **Monitor your runs**: the Actor logs every grape it visits and the wine count per page, which is useful for spotting blocked or empty grape pages early.
6. **Export and analyze**: Download results as CSV for spreadsheet analysis or JSON for programmatic processing.

### FAQ

**Q: How many wines can I extract per grape?**
A: Each grape page shows up to 25 wines per page. The Console pre-fills `maxPagesPerGrape` to 3 (~75 wines), and you can raise it up to 50 (~1,250 wines). Long-tail indigenous grapes will hit their natural ceiling well before that. The scraper stops paginating as soon as Wine-Searcher returns no more rows.

**Q: Does the scraper handle anti-bot protection?**
A: Yes, and you do not have to configure anything. Since v2.0 the fetching is done entirely through a **premium anti-bot proxy service** (JavaScript rendering and anti-bot handling), which handles proxy rotation and fingerprinting on its side. There is no browser in the Actor itself: the earlier Camoufox and Crawlee stack, its session pool and the Apify residential-proxy fallback were all removed in v2.0. The service key belongs to the Actor operator, so you never provide one.

**Q: What happens if a page fails to load?**
A: A page that fails on a transient condition (HTTP 408, 429 or a 5xx, plus network timeouts) is retried once after a 5-second pause. Permanent failures are not retried. A page that still fails is logged as a warning and written to the dataset as a free error row, then the run moves on to the next grape. If five pages fail in a row, the run stops gracefully rather than burning through your timeout.

**Q: What happens when I hit the maximum cost I set for the run?**
A: Each wine is written to the dataset and charged in the same operation, so you are never billed for a wine you did not receive, and never receive a wine that was not billed. When the budget can no longer cover the next wine, the run stops right there, sets a status message saying how many wines were delivered, and makes no further page request.

**Q: Can I scrape an obscure grape that isn't in the dropdown?**
A: Yes. Paste the full Wine-Searcher grape URL into the `customUrl` field. The URL must follow the pattern `https://www.wine-searcher.com/grape-{id}-{slug}` (e.g. `https://www.wine-searcher.com/grape-2120-areni-noir` for the Armenian grape Areni Noir).

**Q: Can I scrape every grape on Wine-Searcher in one run?**
A: Yes. Flip the `scrapeAllGrapes` checkbox to `true`. The Actor walks all 1,054 baked grape varieties. With `maxPagesPerGrape: 3`, expect 5,000 to 15,000 wines, so raise `maxWines` (default 1,000) if you want the sweep to run past a thousand, and check the Pricing tab for what that volume costs on your plan.

**Q: How long does a typical run take?**
A: A single grape with 1 page takes about 30–60 seconds. A single grape paginated to 50 pages takes 15–30 minutes. A full `scrapeAllGrapes` run typically runs 4–8 hours depending on `maxPagesPerGrape` and the proxy backend. The default Actor timeout is 2 hours; raise it explicitly if you launch a deep `scrapeAllGrapes` sweep.

**Q: Are prices always in USD?**
A: Yes, in practice. Every page is fetched through a US connection, so Wine-Searcher shows US dollars. The `currency` field records the currency detected on each row, so you can check it, and `targetCurrency` converts the prices if you need another currency.

**Q: Can I convert all prices to a single currency?**
A: Yes. Set the `targetCurrency` input to one of the 30 most-traded ISO codes (USD, EUR, GBP, CHF, JPY, and 25 others). The scraper fetches a live currency feed at startup (300+ source currencies covered, including Argentine Peso, Colombian Peso, Vietnamese Dong, Indonesian Rupiah, and other emerging-market currencies that some proxy locales return) and adds two fields to each wine: `avg_price_converted` (numeric value) and `target_currency` (ISO code). The original `avg_price` and `currency` are always kept alongside for transparency.

**Q: Can I schedule regular scrapes?**
A: Yes. Use Apify's built-in scheduler to run the Actor on a daily, weekly, or monthly basis. This is useful for tracking grape-level price trends and new releases.

**Q: What grape pages are supported?**
A: Any grape page on Wine-Searcher is supported, anything matching `https://www.wine-searcher.com/grape-{id}-{slug}`. The dropdown ships with 1,054 entries, but `customUrl` accepts any valid grape URL.

### Is it legal to scrape Wine-Searcher?

This scraper only extracts publicly available data that any visitor can see on Wine-Searcher.com: grape rankings, wine ratings, prices, and merchant listings. It does not access private accounts, bypass authentication, or extract personal user data.

When used for legitimate purposes such as market research, price comparison, or wine collection management, web scraping of publicly available data is generally considered acceptable. However, scraped data may be subject to Wine-Searcher's Terms of Service and applicable data protection regulations (GDPR in the EU).

Always use scraped data responsibly and in compliance with your local laws.

### Use it with AI agents and MCP clients

Agents can call this Actor as a tool. Connect your client (Claude, ChatGPT, Cursor or any MCP client) to the Apify MCP server at [mcp.apify.com](https://mcp.apify.com) and add `mrbridge/wine-searcher-grape-scraper`. The agent then reads the input schema, picks a grape and returns the wine rows. See the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp) for the setup, and keep `maxPagesPerGrape` and `maxWines` low in agent runs so a single call stays small.

### Integrate into your workflow

Run this Actor programmatically via the [Apify API](https://docs.apify.com/api/v2), schedule it, push results into your tools, or compose it with other Actors. Get your token from [Settings → Integrations](https://console.apify.com/settings/integrations).

#### Quick API call (cURL)

```bash
curl "https://api.apify.com/v2/acts/mrbridge~wine-searcher-grape-scraper/run-sync-get-dataset-items" \
  -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -d '{"grape": "https://www.wine-searcher.com/grape-384-pinot-noir", "maxPagesPerGrape": 3, "tabFilter": "mostpopular"}'
```

The **API** tab on the Actor page auto-generates equivalent `apify-client` snippets for Node.js and Python.

#### Schedules, webhooks, MCP

| Feature | What it does | Where to configure |
|---------|--------------|--------------------|
| **Schedules** | Run automatically (e.g. `0 2 * * 1` for every Monday 02:00 UTC) | **Schedules** tab → Create schedule from a Task |
| **Webhooks** | POST `{datasetId, runMetadata}` to your endpoint when a run succeeds | **Integrations** tab → Webhooks |
| **MCP** | Expose this Actor as a tool to Claude, ChatGPT, Cursor | **MCP** tab on the Actor page, or [mcp.apify.com](https://mcp.apify.com) |

#### No-code integrations

| Platform | What it does |
|----------|--------------|
| **[Google Sheets / Drive](https://docs.apify.com/platform/integrations)** | Auto-export wine rankings to a Sheet |
| **[Airtable](https://docs.apify.com/platform/integrations/airtable)** | Sync grape data to an Airtable base |
| **[Zapier](https://docs.apify.com/platform/integrations/zapier)** | Trigger 5,000+ apps on run completion |
| **[Make](https://docs.apify.com/platform/integrations/make)** | Visual workflows: scrape → transform → DB |
| **[n8n](https://docs.apify.com/platform/integrations/n8n)** | Self-hosted workflows with the Apify trigger node |

***

### Support

- **Bug reports & questions**: Use the Actor's [Issues tab](https://console.apify.com/actors/qYKWZH35JbyiXzl9g/issues) on Apify Console
- **Feature requests**: same place (Issues tab on the Apify Console)
- An honest review helps other users decide, and you can bookmark this Actor too. For bugs or other problems, use the Issues tab.

# Changelog

This Actor's version history is a separate document: https://apify.com/mrbridge/wine-searcher-grape-scraper/changelog.md

# Actor input Schema

## `grape` (type: `string`):

Choose a grape variety from the list. Pinot Noir by default. For obscure grapes not listed, use the 'Custom Grape URL' field below.

## `customUrl` (type: `string`):

Optional. Overrides the grape selected above by pasting a Wine-Searcher grape URL directly. Useful for very obscure grapes not in the dropdown.

## `scrapeAllGrapes` (type: `boolean`):

Override the dropdown and crawl every grape variety on Wine-Searcher (~1,054). Warning: a full run can produce 5,000-15,000 wines and cost $20-$60.

## `maxWines` (type: `integer`):

Soft cap on total wines extracted, applied BEFORE Apify's spending limit. Default 1000 wines (~$3 PPE at $0.003/wine). Set to 0 for unlimited (PPE + Apify spending limit only). Primary use: protect free-tier accounts in `scrapeAllGrapes` mode where a single run can otherwise produce 5,000-15,000 wines.

## `maxPagesPerGrape` (type: `integer`):

Maximum number of pagination pages to scrape per grape. Each page contains ~25 wines.

## `tabFilter` (type: `string`):

Choose how wines are sorted on each grape page.

## `targetCurrency` (type: `string`):

If set, avg_price, which is in US dollars because pages are fetched through a US connection, is converted to this currency with a live exchange rate. The original price and currency are kept alongside. Leave empty to keep US dollars.

## Actor input object example

```json
{
  "grape": "https://www.wine-searcher.com/grape-384-pinot-noir",
  "scrapeAllGrapes": false,
  "maxWines": 1000,
  "maxPagesPerGrape": 3,
  "tabFilter": "mostpopular",
  "targetCurrency": ""
}
```

# Actor output Schema

## `wines` (type: `string`):

Full dataset of scraped wines with popularity, critics score, price, and source grape variety

## `runSummary` (type: `string`):

JSON record with totalWines (delivered and charged), chargedWineEvents, eventPriceUsd, grapesScraped, pagesScrapedTotal, startUrls, stopReason and field null-rate metrics. A run that ends on an unexpected error writes status 'failed' instead, with errorCode, errorMessage, aborted and the same counters up to the failure.

# 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 = {
    "maxPagesPerGrape": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/wine-searcher-grape-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 = { "maxPagesPerGrape": 3 }

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/wine-searcher-grape-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 '{
  "maxPagesPerGrape": 3
}' |
apify call mrbridge/wine-searcher-grape-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrbridge/wine-searcher-grape-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/qYKWZH35JbyiXzl9g/builds/wJGMUl2N8ADES3OTe/openapi.json