Wine Searcher Scraper — Scores, Prices & Popularity

What is Wine Searcher Scraper from List?

Wine Searcher Scraper from List is an Apify Actor that extracts structured wine data from Wine-Searcher.com, the world's largest wine price comparison site with 18M+ searches per month. Provide wine names, Wine-Searcher URLs or LWIN codes — the scraper returns critic scores, cheapest worldwide prices, winery details and popularity rankings in JSON or CSV format.

No Wine-Searcher account needed, no API key, no rate limits. A pay-per-result alternative to the official Wine-Searcher API.

Features

• Three flexible input modes — search by wine name, paste Wine-Searcher URLs, or use industry-standard LWIN codes
• Critic scores & reviews — aggregated ratings from Wine-Searcher's critic database
• Cheapest worldwide prices — lowest available price with merchant name, excluding auctions and pre-arrival offers
• Winery info & popularity — producer details and Wine-Searcher popularity ranking for each wine
• POS / inventory-ready — paste wine names from your point-of-sale system as-is. Category prefixes, bottle sizes and commas are stripped automatically
• LWIN auto-detection — LWIN7, LWIN11, LWIN16 and LWIN18 codes all accepted. Numeric or string format, with or without inputType
• Smart retry engine — 7 failure categories with per-category retry policy, exponential backoff and jitter
• Pay only for results — $0.025 per wine. Never charged for errors or not-found wines

Which wine scraper should I use?

Need	Best Actor	What it does
Look up specific wines by name, URL or LWIN	Wine Searcher Scraper from List (this one)	Critic scores, cheapest prices, winery info & popularity for each wine
Discover all wines in a region or appellation	Wine-Searcher Region Scraper	Browse and extract wines by region on Wine-Searcher
Get Vivino user ratings & taste profiles	Vivino Wine Data Scraper	Vivino ratings, prices, taste profiles & reviews
Explore wines by region on Vivino	Vivino Wine Scraper	Browse and extract all wines from a Vivino region
Monitor Millesima prices & stock	Millesima Wine Scraper	Prices, stock and critic ratings from Millesima

In short: Use this actor when you have a known list of wines and want Wine-Searcher data (critic scores, market prices, popularity). Use the Region Scraper when you want to discover wines in an appellation.

Tip: Use the Region Scraper to discover wines by appellation, then this actor to get detailed data for each wine.

Why scrape Wine-Searcher?

Wine-Searcher is the world's largest wine price comparison engine with 18+ million searches per month and over 20 million wine offers from 80,000+ merchants worldwide. This data is valuable for:

• Wine retailers & e-commerce: Monitor competitor pricing across global merchants. Compare your catalog prices against the cheapest offers to stay competitive
• Sommeliers & wine buyers: Research scores and pricing before purchasing decisions. Build a structured wine list with critic ratings and current market prices
• Wine collectors & investors: Track the value of your cellar over time. Get popularity rankings and price trends for wines in your collection
• Data analysts & wine tech: Feed structured wine data into dashboards, recommendation engines or pricing models. Export to CSV, JSON or integrate via the Apify API

What data can this scraper extract?

Data Point	Description	Always included
Wine name	Full name as listed on Wine-Searcher	Yes
Appellation	Appellation and country of origin	Yes
Critic score	Aggregated critic score (0–100)	Yes
Critic reviews count	Number of critic reviews	Yes
Wine style	Style descriptor (e.g. "Red - Savory and Classic")	Yes
Cheapest price	Lowest available price worldwide (standard bottle)	Yes
Currency	Currency code (EUR, USD, GBP…)	Yes
Merchant	Merchant offering the lowest price	Yes
Offers count	Total number of merchant offers	Yes
Winery name	Producer / winery name	Yes
Winery URL	Winery page URL on Wine-Searcher	Yes
Popularity ranking	Wine-Searcher popularity ranking	Yes
Wine-Searcher URL	Direct link to the wine page	Yes
Scraped at	ISO timestamp of extraction	Yes

Quick Start — Test in 60 seconds

1. Click "Try for free" to open this actor in Apify Console
2. The default input includes sample wines — leave them or paste your own
3. Click "Start"
4. Download your results from the Dataset tab (JSON, CSV, Excel)

That's it! No Wine-Searcher account needed, no API key, no rate limits.

Maximum 500 wines per run. For larger catalogs, split your list across multiple runs.

Option 1: Search by wine name

1. Go to the Wine Searcher Scraper from List on Apify
2. Select "Wine Names" from the input type dropdown
3. Enter wine names — one per line. Include the full domaine name and the vintage year for the most accurate match
4. Click Start to run the scraper

Example:

Domaine Leflaive Puligny-Montrachet Les Pucelles 2020 Château Beaucastel Hommage à Jacques Perrin 2019

Tips: The more specific the name, the more accurate the match. "Petrus 2015" works, but "Domaine du Château de Meursault Meursault Les Charmes 2020" is more precise.

POS / inventory systems? If your wine list comes from a point-of-sale or inventory system with category prefixes and bottle sizes (e.g. Champagne, Dom Perignon Brut, 2013, Champagne, France or Dessert Wine, Dolce Late Harvest (375ml), Napa Valley), just paste them as-is — the actor automatically cleans the names before searching.

Option 2: Provide Wine-Searcher URLs

1. Select "Wine-Searcher URLs" from the input type dropdown
2. Paste one Wine-Searcher URL per line — any URL from wine-searcher.com/find/... works
3. Click Start

Example:

https://www.wine-searcher.com/find/lwin11316442021 https://www.wine-searcher.com/find/petrus/2015

Option 3: Use LWIN codes

1. Select "LWIN Codes" from the input type dropdown
2. Enter one LWIN code per line. Supports all formats:
   • LWIN11 (10-11 digits) — specific wine + vintage, e.g. 11316442021
   • LWIN7 (7 digits) — wine across all vintages, e.g. 1131644
   • LWIN16/LWIN18 — automatically truncated to LWIN11
3. Click Start

Example:

11316442021 11084042019 1131644

LWIN (Liquid Wine Identifier Number) is the global standard for identifying wines. You can find LWIN codes on Liv-ex, Wine-Searcher, or your wine management software.

How do I configure the scraper?

Parameter	Type	Default	Description
inputType	string	auto-detected	How wines are identified: wineNames, urls or lwins. Auto-detected if omitted
wineNames	array	—	Wine names to search on Wine-Searcher (max 500)
urls	array	—	Direct Wine-Searcher URLs (max 500)
lwins	array	—	LWIN codes — string or number format (max 500)
proxyCountry	string	FR	Proxy country — determines which prices and offers are shown (e.g. FR, US, GB)

Example: Search by wine name

{
    "inputType": "wineNames",
    "wineNames": [
        "Domaine Leflaive Puligny-Montrachet Les Pucelles 2020",
        "Petrus 2015",
        "Opus One 2019"
    ],
    "proxyCountry": "FR"
}

Example: Scrape by LWIN codes

{
    "inputType": "lwins",
    "lwins": ["11316442021", "11084042019", "1131644"]
}

Output example

{
  "inputValue": "11316442021",
  "inputType": "lwin",
  "wineSearcherUrl": "https://www.wine-searcher.com/find/lwin11316442021",
  "wineName": "2021 Domaine Jean-Claude Bachelet et Fils Blanchot du Dessus",
  "appellation": "Chassagne-Montrachet Premier Cru, France",
  "score": 92,
  "criticReviewsCount": 2,
  "style": "White - Buttery and Complex",
  "cheapestPriceAmount": 459.76,
  "cheapestPriceCurrency": "EUR",
  "cheapestPriceMerchant": "Lay & Wheeler Wine Merchants",
  "offersCount": 5,
  "offersPages": 1,
  "wineryName": "Jean-Claude Bachelet",
  "wineryUrl": "https://www.wine-searcher.com/merchant/22937-jean-claude-bachelet",
  "winePopularity": "2,622nd",
  "scrapedAt": "2025-03-07T10:00:00.000Z"
}

How much does it cost?

Tier	Cost	What you get
Per result	$0.025/wine	Pay only for extracted data, not compute time
Free tier	$5 free credits/month	~200 wines for free every month
Starter plan	$49/month	~2,000 wines/month

This Actor uses Apify's pay-per-event pricing. No setup fee — you only pay for wines successfully extracted. Start with $5 free credits.

Estimates based on event pricing only. Actual costs may include minimal platform compute fees. The free $5 credit covers both.

Cost estimates

Wines	Cost
10	$0.25
100	$2.50
500	$12.50

What's free:

• Wines not found on Wine-Searcher
• Failed extractions (network errors, rate limits)

Tips for best results

1. Include vintage years in wine names for precise matching (e.g., "Petrus 2015" instead of "Petrus")
2. Use LWIN codes when available — they're the most reliable input mode with zero ambiguity
3. POS / inventory lists can be pasted directly — the actor strips category prefixes, bottle sizes and commas automatically
4. Set the proxy country to your target market (e.g. FR for France, US for United States) to see pricing relevant to that region
5. Keep the default timeout (2 hours) — it's safe for all batch sizes up to 500 wines
6. For large batches (500 wines), expect 30-60 minutes of runtime

Integrate into Your Workflow

This actor is designed to fit into automated pipelines that keep your wine database up to date. Below are the most common integration patterns — from zero-code solutions to full programmatic control.

API Integration

Call this actor programmatically using the Apify API. Get your API token from Settings → Integrations in the Apify Console.

Synchronous Call (wait for results)

Best for small batches (< 50 wines). The request blocks until the run finishes and returns results directly. Maximum wait: 300 seconds.

cURL:

curl "https://api.apify.com/v2/acts/mrbridge~wine-searcher-scraper-from-list/run-sync-get-dataset-items" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -d '{
    "inputType": "lwins",
    "lwins": ["11316442021", "11084042019"]
  }'

Asynchronous Call (start and poll)

Best for large batches. The request returns immediately with a runId — poll for status or use a webhook to get notified when done.

cURL — Start the run:

curl "https://api.apify.com/v2/acts/mrbridge~wine-searcher-scraper-from-list/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -d '{
    "inputType": "lwins",
    "lwins": ["11316442021", "11084042019"]
  }'

cURL — Fetch results when done:

curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"

Node.js:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

// .call() starts the run and waits for it to finish
const run = await client.actor('mrbridge/wine-searcher-scraper-from-list').call({
    inputType: 'lwins',
    lwins: ['11316442021', '11084042019'],
});

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

Python:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

# .call() starts the run and waits for it to finish
run = client.actor("mrbridge/wine-searcher-scraper-from-list").call(run_input={
    "inputType": "lwins",
    "lwins": ["11316442021", "11084042019"],
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)

Dataset Export Formats

Results can be exported in multiple formats by appending ?format= to the dataset URL:

Format	Parameter	Use case
JSON	?format=json	APIs, databases, programmatic use
CSV	?format=csv	Spreadsheets, data import tools
Excel	?format=xlsx	Business reports, manual review
XML	?format=xml	Legacy systems, ERP integrations
JSON Lines	?format=jsonl	Streaming, large-file processing

Filter fields: ?fields=wineName,score,cheapestPriceAmount or exclude them: ?omit=wineSearcherUrl,inputType.

Scheduled Runs — Automatic Price Tracking

Set up a schedule in the Apify Console to track wine prices over time:

1. Create a Task with your saved input (wine list, proxy country, etc.)
2. Go to the Schedules tab → Create schedule
3. Set a cron expression — e.g. 0 2 * * * for daily at 2 AM UTC
4. Combine with a webhook (below) to push results to your database automatically

Schedule	Cron expression	Use case
Daily at 2 AM	0 2 * * *	Price monitoring
Every Monday	0 8 * * 1	Weekly reports
Every 6 hours	0 */6 * * *	Active trading desk
1st of month	0 0 1 * *	Monthly portfolio valuation

Webhooks — Push Results to Your System

Get notified when a run completes — no polling needed:

1. Go to the actor's Integrations tab in the Apify Console
2. Select event: Run succeeded
3. Enter your endpoint URL (e.g. https://your-api.com/webhooks/wine-data)
4. Apify sends a POST request with the datasetId and run metadata

Your server then:

# Example: Flask webhook handler → PostgreSQL
import requests
from apify_client import ApifyClient

@app.route("/webhooks/wine-data", methods=["POST"])
def handle_wine_webhook():
    data = request.json
    dataset_id = data["resource"]["defaultDatasetId"]

    client = ApifyClient("YOUR_APIFY_TOKEN")
    wines = client.dataset(dataset_id).list_items().items

    for wine in wines:
        db.execute(
            "INSERT INTO wines (lwin, name, score, price, currency, merchant, popularity, scraped_at) "
            "VALUES (%s, %s, %s, %s, %s, %s, %s, %s) "
            "ON CONFLICT (lwin) DO UPDATE SET score=EXCLUDED.score, price=EXCLUDED.price, scraped_at=EXCLUDED.scraped_at",
            (wine["inputValue"], wine["wineName"], wine["score"],
             wine["cheapestPriceAmount"], wine["cheapestPriceCurrency"],
             wine["cheapestPriceMerchant"], wine["winePopularity"], wine["scrapedAt"])
        )
    return "OK", 200

Database Integration — Full Example

A complete pipeline: schedule → scrape → insert into your database.

Node.js + PostgreSQL:

import { ApifyClient } from 'apify-client';
import pg from 'pg';

const apify = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const db = new pg.Pool({ connectionString: 'postgresql://user:pass@host:5432/winedb' });

// 1. Run the actor with your wine list
const run = await apify.actor('mrbridge/wine-searcher-scraper-from-list').call({
    inputType: 'lwins',
    lwins: ['11316442021', '11084042019', '1131644'],
});

// 2. Fetch results
const { items } = await apify.dataset(run.defaultDatasetId).listItems();

// 3. Upsert into database
for (const wine of items) {
    if (wine.error || wine.notFound) continue; // skip failed extractions
    await db.query(
        `INSERT INTO wines (lwin, name, appellation, score, price, currency, merchant, popularity, scraped_at)
         VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)
         ON CONFLICT (lwin) DO UPDATE SET
           score=EXCLUDED.score, price=EXCLUDED.price, merchant=EXCLUDED.merchant,
           popularity=EXCLUDED.popularity, scraped_at=EXCLUDED.scraped_at`,
        [wine.inputValue, wine.wineName, wine.appellation, wine.score,
         wine.cheapestPriceAmount, wine.cheapestPriceCurrency,
         wine.cheapestPriceMerchant, wine.winePopularity, wine.scrapedAt]
    );
}
console.log(`Upserted ${items.filter(w => !w.error && !w.notFound).length} wines`);

Python + SQLite (simple):

import sqlite3
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("mrbridge/wine-searcher-scraper-from-list").call(run_input={
    "inputType": "wineNames",
    "wineNames": ["Petrus 2015", "Opus One 2019"],
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
conn = sqlite3.connect("wines.db")

for wine in items:
    if "error" in wine or wine.get("notFound"):
        continue
    conn.execute(
        "INSERT OR REPLACE INTO wines (input, name, score, price, currency, scraped_at) VALUES (?,?,?,?,?,?)",
        (wine["inputValue"], wine["wineName"], wine["score"],
         wine["cheapestPriceAmount"], wine["cheapestPriceCurrency"], wine["scrapedAt"])
    )

conn.commit()

No-Code Integrations

Connect this actor to your tools without writing code:

Platform	What it does	Setup
Google Sheets	Export results to a Google Sheet automatically	Integrations tab → Google Drive
Airtable	Sync wine data to an Airtable base with field mapping	Integrations tab → Airtable
Zapier	Trigger Zaps on run completion → push to 5,000+ apps	Apify Zapier connector
Make	Visual workflows: scrape → transform → insert into DB	Apify Make module
n8n	Self-hosted workflow automation with Apify trigger node	Apify n8n community node

Example — Google Sheets price tracker:

1. Open the actor's Integrations tab → select Google Sheets
2. Map fields: wineName → Name, score → Score, cheapestPriceAmount → Price
3. Schedule a weekly run → your sheet updates automatically every Monday

Handling Large Catalogs (> 500 wines)

For catalogs larger than 500 wines, split your list into batches and chain the runs:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
all_lwins = [...]  # your full list, e.g. 2000 wines

# Split into batches of 500
batches = [all_lwins[i:i+500] for i in range(0, len(all_lwins), 500)]
all_results = []

for batch in batches:
    run = client.actor("mrbridge/wine-searcher-scraper-from-list").call(
        run_input={"inputType": "lwins", "lwins": batch},
        timeout_secs=3600,
    )
    items = client.dataset(run["defaultDatasetId"]).list_items().items
    all_results.extend(items)

print(f"Total: {len(all_results)} wines scraped across {len(batches)} batches")

Troubleshooting

"Wine not found" in results

• Check for typos in the wine name
• Include the full producer name (e.g., "Domaine Leflaive Puligny-Montrachet" instead of "Puligny-Montrachet")
• Add or remove the vintage year
• Very rare or brand-new wines may not be in Wine-Searcher's database
• The result will include "notFound": true — no charge applies

Prices differ from what I see on Wine-Searcher

• Prices depend on the proxyCountry setting — different countries see different merchant offers
• Try changing proxyCountry to match the region you're interested in (e.g., US for United States, GB for United Kingdom)
• Auctions, pre-arrival and "by request" offers are always excluded

Wrong wine returned for a name search

• Use LWIN codes for guaranteed accuracy (no ambiguity)
• Include the full domaine name and vintage year
• Use Wine-Searcher URLs as a fallback — they're the most reliable input mode

Run timed out

• The default timeout (2 hours) is safe for up to 500 wines
• If you override the timeout via the API, use this formula: max(120, batchSize × 8) seconds
• For 500 wines, set at least 3,600 seconds (60 minutes)

Batch size	Recommended minimum timeout
1 wine	2 min (120s)
10 wines	5 min (300s)
100 wines	15 min (900s)
500 wines	60 min (3,600s)

Which bottle format is used for prices?

Standard 75cl bottles by default. If no 75cl offer is available, the actor falls back to 62.5cl (common for Tokaji and some dessert wines), then 50cl. Auctions, pre-arrival and "by request" offers are always excluded.

FAQ

Does Wine-Searcher have an official API? Yes, but it's expensive and restricted. This actor provides a pay-per-result alternative at $0.025/wine with no monthly commitment.

How fast is the scraper? The actor scrapes 30 wines in parallel. A full 500-wine batch typically completes in 30-60 minutes.

What are LWIN codes and where can I find them? LWIN (Liquid Wine Identifier Number) is the wine industry's universal identification system managed by Liv-ex. LWIN7 identifies a wine regardless of vintage; LWIN11 adds the vintage year. You can look up LWINs on Liv-ex, Wine-Searcher itself, or your wine management platform.

How does the proxy country setting affect results? The proxy country determines which prices and merchant offers are shown. Set it to your target market (e.g. "FR" for France, "US" for United States, "GB" for United Kingdom) to see pricing relevant to that region. Default is "FR".

Is there a rate limit? The actor includes built-in rate limiting and retry logic to avoid being blocked. Concurrency is automatically optimized.

Can I send LWIN codes as numbers instead of strings? Yes. API clients (n8n, Make, Python, etc.) can send LWIN codes as numbers ([1067130]) or strings (["1067130"]) — both work.

Can I omit the inputType field? Yes. The actor auto-detects the input type from whichever array field is populated (lwins, urls, or wineNames).

Can I integrate this with my existing tools? Yes — see the Integrate into Your Workflow section for scheduled runs, webhooks, database examples (PostgreSQL, SQLite), and no-code integrations (Airtable, Google Sheets, Zapier, Make, n8n).

Is my data stored? Your results are stored in your Apify dataset for 31 days (default retention). No wine data is shared with third parties. You control your data and can delete it at any time.

Can I export results to Google Sheets or Excel? Yes. Use the built-in Google Sheets integration for automatic export, or download results as CSV/Excel from the Dataset tab.

Privacy & Security

• No Wine-Searcher account required — the scraper accesses only publicly available data
• No personal data collected — no user accounts, passwords, or personal information are accessed
• Your data stays private — results are stored only in your Apify dataset, never shared
• Scraping API key managed by the actor — you don't need to provide or manage any external API key
• GDPR compliant — no personal data is processed or stored beyond your own dataset

Resources

• Apify API Documentation — Full API reference for programmatic access
• Apify Platform Integrations — Connect to Google Sheets, Zapier, Make, n8n, and more
• Apify Proxy Documentation — Configure residential or datacenter proxies
• Wine-Searcher Region Scraper — Discover wines by region
• Vivino Wine Data Scraper — Vivino ratings, prices and taste profiles
• Millesima Wine Scraper — Millesima prices and critic ratings

License

This Actor is provided as-is for personal and commercial use. It extracts only publicly available data from Wine-Searcher. Usage must comply with applicable laws and Wine-Searcher's Terms of Service. This tool is not affiliated with or endorsed by Wine-Searcher.

Changelog

Showing the 10 most recent updates.

• 0.1.77 (2026-04-25) — README optimized for Apify Store: new structure with Quick Start, cross-selling table, troubleshooting, privacy, tips and more
• 0.1.76 (2026-04-22) — POS/inventory wine name cleaning: category prefixes, bottle sizes and commas are stripped automatically before searching
• 0.1.74 (2026-04-21) — Fixed: numeric LWIN codes and missing inputType no longer crash the actor
• 0.1.73 (2026-04-20) — Unified pipeline: single-pass architecture improves throughput by ~15-20% on large batches
• 0.1.71 (2026-04-20) — Internal optimizations and cleanup
• 0.1.69 (2026-04-19) — API & workflow integration guide: sync/async API examples, webhooks, scheduled runs, database integration, no-code integrations
• 0.1.63 (2026-04-19) — Run analytics persisted to KV Store, timeout guidance in input UI, review solicitation
• 0.1.62 (2026-04-19) — LWIN16/LWIN18 support: longer codes automatically truncated to LWIN11
• 0.1.60 (2026-04-17) — Fixed duplicate dataset entries on long runs caused by container migration
• 0.1.56 (2026-04-16) — Retry strategy overhaul: 7 failure categories with per-category retry policy

---

Built with Apify.