# Vivino Scraper (`solidcode/vivino-scraper`) Actor \[πŸ’° $1.8 / 1K] Extract structured wine data from Vivino: name, winery, vintage, region, grape varieties, ratings, price, taste profile, food pairings, and optional user reviews. Search by keyword or paste wine URLs. - **URL**: https://apify.com/solidcode/vivino-scraper.md - **Developed by:** [SolidCode](https://apify.com/solidcode) (community) - **Categories:** E-commerce, Other - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing from $1.80 / 1,000 results This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are 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.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Scraper Pull structured wine data from Vivino at scale β€” winery, vintage, region, grape varieties, community ratings, live pricing, full taste profiles, food pairings, and opt-in reviews. Search by wine name or paste Vivino URLs directly, and localize prices across 23 countries and 15 currencies. Built for wine retailers, sommeliers, market researchers, and catalog teams who need clean, comparable wine data without manually copying it bottle by bottle from Vivino. ### Why This Scraper? - **Full taste profiles on every wine** β€” body, acidity, tannins, sweetness, and fizziness on a measured scale, plus the dominant flavor-note groups Vivino's community tasted. - **Community ratings backed by rating counts** β€” every wine carries an average rating *and* the number of ratings behind it, so you can weight a 4.5 from 12,000 tasters against a 4.5 from 9. - **Up to 100 community reviews per wine** β€” each with reviewer username, their rating, the full comment text, and the review date, emitted as its own row for easy analysis. - **Localized pricing across 23 countries and 15 currencies** β€” quote prices in USD, GBP, EUR, CHF, AUD, JPY, and more to match the market you actually sell into. - **Gather every vintage of a wine, or pin to one exact year** β€” "Ignore vintage" sweeps all release years for price-over-time analysis; "Match exact vintage" locks to the year you typed. - **Grape varieties and food pairings out of the box** β€” the grape blend and Vivino's suggested pairings come back as clean arrays, ready to filter or join. - **Alcohol content, region, and country on every bottle** β€” ABV percentage plus the wine's region and country of origin, without a second lookup. - **Mix search queries and direct URLs in one run** β€” paste a list of wine names, a list of Vivino wine URLs, or both, and let each run independently. ### Use Cases **Wine Retail & Pricing** - Monitor competitor and market pricing on the same wine across countries - Track a vintage's price as it moves from current release to back-vintage - Spot under-rated, well-priced bottles by comparing rating to price - Validate landed costs against local market currency before importing **Restaurants & Sommeliers** - Build a by-the-glass and bottle list ranked by community rating - Match wines to menu courses using the food-pairing fields - Surface crowd-pleasers with high ratings *and* high rating counts - Find structurally similar alternatives using body, acidity, and tannin scores **Market Research & Trends** - Track how a region or grape variety is rated across thousands of wines - Benchmark a producer's portfolio against its peers - Analyze taste-profile trends by region, country, or vintage year - Quantify community sentiment from review text and ratings **App & Catalog Building** - Enrich an e-commerce wine catalog with ratings, images, and tasting notes - Power a wine-recommendation engine with taste-profile vectors - Populate a wine app with structured pairings, grapes, and ABV - Fill gaps in a product database using direct Vivino URL lookups ### Getting Started #### Search by Wine Name The simplest run β€” one query, full taste profile on by default: ```json { "searchQueries": ["Barolo"], "maxResults": 50 } ```` #### Track Every Vintage of a Wine Strip the vintage to gather all release years of a single wine, priced in euros: ```json { "searchQueries": ["Tignanello"], "vintageHandling": "name_only", "countryCode": "FR", "currencyCode": "EUR", "maxResults": 100 } ``` #### Pull a Wine With Community Reviews Look up specific bottles by URL and collect up to 25 reviews each: ```json { "startUrls": [ "https://www.vivino.com/wineries/antinori/wines/tignanello/w/1768523" ], "includeReviews": true, "maxReviewsPerWine": 25 } ``` #### Full-Featured Example Mix queries and URLs, exact vintage matching, reviews on, localized to the UK: ```json { "searchQueries": ["Penfolds Grange 2017", "Napa Cabernet Sauvignon"], "startUrls": [ "https://www.vivino.com/wineries/penfolds/wines/grange/w/1146" ], "vintageHandling": "name_and_vintage", "includeTasteProfile": true, "includeReviews": true, "maxReviewsPerWine": 50, "countryCode": "GB", "currencyCode": "GBP", "maxResults": 200 } ``` ### Input Reference #### What to Scrape | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `searchQueries` | string\[] | `["Tignanello 2019"]` | Wine names or keywords to search on Vivino (e.g. "Barolo", "Penfolds Grange"). Include the vintage year or leave it out. Each query runs independently. | | `startUrls` | string\[] | `[]` | Paste Vivino wine URLs directly. Each URL is fetched as a single wine. | #### Results | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `maxResults` | integer | `100` | Maximum number of **wines** to return across all queries and URLs. Set to `0` for unlimited. Start with 10–50 to test, then increase. This caps wines only β€” when reviews are on, each wine adds up to `maxReviewsPerWine` review rows on top of this number. | | `vintageHandling` | select | `Smart (detect year automatically)` | How vintage years are matched: detect a year in your query automatically, match the exact year you typed, or ignore the year and return every vintage of the wine. | #### Detail | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `includeTasteProfile` | boolean | `true` | Collect the taste profile β€” body, acidity, tannins, sweetness, fizziness, dominant flavor notes, and food pairings. | #### Reviews | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `includeReviews` | boolean | `false` | Also collect user reviews. Each review is its own result row, added on top of the `maxResults` wine count, so total results grow with the number of reviews collected. | | `maxReviewsPerWine` | integer | `10` | Maximum reviews to collect per wine (across all of its vintages) when reviews are on. Up to `100`. Ignored when reviews are off. | #### Localization | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `countryCode` | select | `United States` | Country market used for pricing and availability. 23 countries supported. | | `currencyCode` | select | `US Dollar` | Currency for wine prices (ISO 4217). 15 currencies supported. | ### Output Every row carries a `recordType` field β€” `wine` or `review` β€” so you can filter cleanly downstream. #### Wine (`recordType: "wine"`) ```json { "recordType": "wine", "wineId": "1768523", "vintageId": "162938511", "name": "Antinori Tignanello", "url": "https://www.vivino.com/en/antinori-tignanello/w/1768523", "winery": "Antinori", "vintage": "2019", "wineType": "Red", "region": "Toscana IGT", "country": "Italy", "grapes": ["Sangiovese", "Cabernet Sauvignon", "Cabernet Franc"], "averageRating": 4.4, "ratingsCount": 28714, "price": 129.99, "currency": "USD", "imageUrl": "https://images.vivino.com/thumbs/example.png", "foodPairings": ["Beef", "Lamb", "Game (deer, venison)"], "description": "A Tuscan icon blending Sangiovese with Bordeaux varieties.", "alcoholContent": 13.5, "body": 4.2, "acidity": 3.1, "tannins": 3.8, "sweetness": 1.4, "fizziness": null, "flavorNotes": [ { "group": "oak", "score": 34699, "count": 240 }, { "group": "red_fruit", "score": 29551, "count": 209 } ], "inputSource": "search", "searchQuery": "Tignanello 2019", "scrapedAt": "2026-05-29T14:30:00Z" } ``` ##### Core Fields | Field | Type | Description | |-------|------|-------------| | `recordType` | string | Always `"wine"` | | `wineId` | string | Vivino wine identifier | | `vintageId` | string | Vivino vintage identifier β€” the rated, priced bottle | | `name` | string | Wine name | | `url` | string | Canonical Vivino wine URL | | `winery` | string | Winery / producer name | | `vintage` | string | Vintage year, or `"N.V."` for non-vintage wines | | `wineType` | string | Red, White, RosΓ©, Sparkling, Dessert, or Fortified | | `region` | string | Wine region | | `country` | string | Country of origin | | `grapes` | string\[] | Grape varieties in the blend | | `imageUrl` | string | Bottle / label image | | `description` | string | Wine description when Vivino provides one | | `alcoholContent` | number | Alcohol by volume (ABV %) | | `inputSource` | string | `search` or `url` β€” how this row was found | | `searchQuery` | string | The query or URL that produced this row | | `scrapedAt` | string | ISO timestamp of extraction | ##### Ratings & Pricing | Field | Type | Description | |-------|------|-------------| | `averageRating` | number | Community average rating (0–5) | | `ratingsCount` | integer | Number of community ratings behind the average | | `price` | number | Price in the selected currency | | `currency` | string | Currency code (ISO 4217) | | `foodPairings` | string\[] | Vivino's suggested food pairings | ##### Taste Profile Populated when `includeTasteProfile` is on. | Field | Type | Description | |-------|------|-------------| | `body` | number | Light-to-full body score | | `acidity` | number | Soft-to-acidic score | | `tannins` | number | Smooth-to-tannic score | | `sweetness` | number | Dry-to-sweet score | | `fizziness` | number | Still-to-fizzy score (sparkling wines) | | `flavorNotes` | object\[] | Dominant flavor-note groups, each with a `group` name, a `score` (how strongly the community tasted it), and a `count` (mentions behind it) | #### Review (`recordType: "review"`) Emitted only when `includeReviews: true`. Capped at `maxReviewsPerWine` per wine. ```json { "recordType": "review", "wineId": "1768523", "vintageId": "162938511", "wineUrl": "https://www.vivino.com/en/antinori-tignanello/w/1768523", "username": "winelover_42", "rating": 4.5, "comment": "Silky tannins, dark cherry, and a long finish. Worth the splurge.", "date": "2026-03-18T09:12:00Z" } ``` | Field | Type | Description | |-------|------|-------------| | `recordType` | string | Always `"review"` | | `wineId` | string | Parent wine identifier | | `vintageId` | string | Parent vintage identifier | | `wineUrl` | string | Parent wine URL | | `username` | string | Reviewer's Vivino username | | `rating` | number | Reviewer's own rating (0–5) | | `comment` | string | Full review text | | `date` | string | Review date | ### Tips for Best Results - **Strip the vintage to track a wine across release years.** Set `vintageHandling` to "Ignore vintage" and the scraper returns every year of a wine β€” ideal for charting how a label's price moves from current release to back vintage. - **Weight ratings by their count.** A 4.6 from 50,000 tasters is far stronger signal than a 4.6 from 8. Sort or filter on `ratingsCount` alongside `averageRating` before you trust a score. - **Reviews add on top of your `maxResults` cap.** `maxResults` limits the number of *wines*; it does not bound reviews. Each review is a separate billable row added on top, capped at `maxReviewsPerWine` per wine (across its vintages). So a 50-wine run with `maxReviewsPerWine: 100` can return up to 50 wines + 5,000 reviews. Reviews are off by default β€” turn them on deliberately and set `maxReviewsPerWine` to keep result counts predictable. - **Set currency and country to your real market.** `currencyCode` controls the price currency and `countryCode` localizes availability β€” match both to the market you sell into so the prices you see are the prices your customers see. - **Start small, then scale.** Run 10–50 results first to confirm the wines and fields match what you expect, then raise `maxResults` (or set it to `0` for unlimited). - **Mix names and URLs in one run.** Combine a list of search terms with a list of specific Vivino URLs to cover broad discovery and exact lookups in a single pass. - **Use the taste-profile scores to find alternatives.** Body, acidity, and tannin values let you match a sold-out favorite to a structurally similar bottle that's still in stock. ### Pricing **$1.80 per 1,000 results** β€” roughly 40% below the going market rate for Vivino wine data, with taste profiles bundled in at no extra charge. | Results | Estimated Cost | |---------|----------------| | 100 | $0.18 | | 1,000 | $1.80 | | 10,000 | $18.00 | | 100,000 | $180.00 | A "result" is any row in the output dataset β€” a wine or a single review. **No compute charges β€” you only pay per result returned.** Reviews are off by default; turning them on adds one billable row per review collected. ### Integrations Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via: - **Zapier** / **Make** / **n8n** β€” Workflow automation - **Google Sheets** β€” Direct spreadsheet export - **Slack** / **Email** β€” Notifications on new results - **Webhooks** β€” Trigger custom APIs on run completion - **Apify API** β€” Full programmatic access ### Legal & Ethical Use This actor is designed for legitimate wine retail research, market analysis, catalog enrichment, and product discovery. Users are responsible for complying with applicable laws and Vivino's terms of service, including making reasonable-rate requests and respecting content usage rules. Review text and usernames are user-generated content β€” handle any personal data responsibly and in line with applicable privacy regulations. Do not use extracted data for spam, harassment, or any illegal purpose. # Actor input Schema ## `searchQueries` (type: `array`): Wine names or keywords to search on Vivino (e.g. 'Tignanello 2019', 'Barolo', or 'Penfolds Grange'). You can include the vintage year or leave it out. Each query runs independently. Leave empty if you only want to scrape specific URLs below. ## `startUrls` (type: `array`): Paste Vivino wine URLs directly (e.g. 'https://www.vivino.com/wineries/.../wines/...' or 'https://www.vivino.com/.../w/123456'). Each URL is fetched as a single wine. ## `maxResults` (type: `integer`): Maximum number of WINES to return across all queries and URLs. Set to 0 for unlimited (up to the site's own limits). Note: this caps wines only β€” if Include User Reviews is on, each wine can add up to 'Maximum Reviews per Wine' review rows on top of this number. Tip: start with 10-50 to test, then increase. ## `vintageHandling` (type: `string`): How to handle the vintage year when searching by name. 'Smart' detects a year in your query automatically. 'Match exact vintage' only returns the exact year you typed. 'Ignore vintage' returns the wine regardless of year (uses the latest or most-rated vintage). ## `includeTasteProfile` (type: `boolean`): Also collect the wine's taste profile: body, acidity, tannins, sweetness, fizziness, dominant flavor notes, and food pairings. On by default. ## `includeReviews` (type: `boolean`): Also collect user reviews for each wine. Off by default. When on, each review is returned as its own result, so the total result count grows with the number of reviews. Use the cap below to keep this predictable. ## `maxReviewsPerWine` (type: `integer`): When Include User Reviews is on, the maximum number of reviews to collect per wine (across all of its vintages). For example, 100 means at most 100 reviews for any single wine, no matter how many vintages it has. Each review is returned as its own result and counts toward your results. Ignored when reviews are off. ## `countryCode` (type: `string`): Country market used for pricing and availability. Use the country your prices should reflect. Currency (below) always applies; country-level localization depends on regional availability and may fall back to the nearest market for some wines. ## `currencyCode` (type: `string`): Currency for wine prices (ISO 4217). ## Actor input object example ```json { "searchQueries": [ "Tignanello 2019" ], "startUrls": [], "maxResults": 100, "vintageHandling": "auto", "includeTasteProfile": true, "includeReviews": false, "maxReviewsPerWine": 10, "countryCode": "US", "currencyCode": "USD" } ``` # Actor output Schema ## `overview` (type: `string`): Table of scraped wines with key fields. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "searchQueries": [ "Tignanello 2019" ], "startUrls": [], "maxResults": 100, "vintageHandling": "auto", "includeTasteProfile": true, "includeReviews": false, "maxReviewsPerWine": 10, "countryCode": "US", "currencyCode": "USD" }; // Run the Actor and wait for it to finish const run = await client.actor("solidcode/vivino-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "searchQueries": ["Tignanello 2019"], "startUrls": [], "maxResults": 100, "vintageHandling": "auto", "includeTasteProfile": True, "includeReviews": False, "maxReviewsPerWine": 10, "countryCode": "US", "currencyCode": "USD", } # Run the Actor and wait for it to finish run = client.actor("solidcode/vivino-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 '{ "searchQueries": [ "Tignanello 2019" ], "startUrls": [], "maxResults": 100, "vintageHandling": "auto", "includeTasteProfile": true, "includeReviews": false, "maxReviewsPerWine": 10, "countryCode": "US", "currencyCode": "USD" }' | apify call solidcode/vivino-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=solidcode/vivino-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Vivino Scraper", "description": "[πŸ’° $1.8 / 1K] Extract structured wine data from Vivino: name, winery, vintage, region, grape varieties, ratings, price, taste profile, food pairings, and optional user reviews. Search by keyword or paste wine URLs.", "version": "1.0", "x-build-id": "5oOXvM03KiJtAwyYV" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/solidcode~vivino-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-solidcode-vivino-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/solidcode~vivino-scraper/runs": { "post": { "operationId": "runs-sync-solidcode-vivino-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/solidcode~vivino-scraper/run-sync": { "post": { "operationId": "run-sync-solidcode-vivino-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", "properties": { "searchQueries": { "title": "Search Queries", "type": "array", "description": "Wine names or keywords to search on Vivino (e.g. 'Tignanello 2019', 'Barolo', or 'Penfolds Grange'). You can include the vintage year or leave it out. Each query runs independently. Leave empty if you only want to scrape specific URLs below.", "items": { "type": "string" } }, "startUrls": { "title": "Vivino URLs", "type": "array", "description": "Paste Vivino wine URLs directly (e.g. 'https://www.vivino.com/wineries/.../wines/...' or 'https://www.vivino.com/.../w/123456'). Each URL is fetched as a single wine.", "items": { "type": "string" } }, "maxResults": { "title": "Maximum Results", "minimum": 0, "type": "integer", "description": "Maximum number of WINES to return across all queries and URLs. Set to 0 for unlimited (up to the site's own limits). Note: this caps wines only β€” if Include User Reviews is on, each wine can add up to 'Maximum Reviews per Wine' review rows on top of this number. Tip: start with 10-50 to test, then increase.", "default": 100 }, "vintageHandling": { "title": "Vintage Handling", "enum": [ "auto", "name_and_vintage", "name_only" ], "type": "string", "description": "How to handle the vintage year when searching by name. 'Smart' detects a year in your query automatically. 'Match exact vintage' only returns the exact year you typed. 'Ignore vintage' returns the wine regardless of year (uses the latest or most-rated vintage).", "default": "auto" }, "includeTasteProfile": { "title": "Include Taste Profile", "type": "boolean", "description": "Also collect the wine's taste profile: body, acidity, tannins, sweetness, fizziness, dominant flavor notes, and food pairings. On by default.", "default": true }, "includeReviews": { "title": "Include User Reviews", "type": "boolean", "description": "Also collect user reviews for each wine. Off by default. When on, each review is returned as its own result, so the total result count grows with the number of reviews. Use the cap below to keep this predictable.", "default": false }, "maxReviewsPerWine": { "title": "Maximum Reviews per Wine", "minimum": 1, "maximum": 100, "type": "integer", "description": "When Include User Reviews is on, the maximum number of reviews to collect per wine (across all of its vintages). For example, 100 means at most 100 reviews for any single wine, no matter how many vintages it has. Each review is returned as its own result and counts toward your results. Ignored when reviews are off.", "default": 10 }, "countryCode": { "title": "Country", "enum": [ "US", "GB", "FR", "DE", "ES", "IT", "NL", "BE", "PT", "CH", "AT", "SE", "DK", "IE", "CA", "AU", "NZ", "JP", "HK", "SG", "BR", "MX", "ZA" ], "type": "string", "description": "Country market used for pricing and availability. Use the country your prices should reflect. Currency (below) always applies; country-level localization depends on regional availability and may fall back to the nearest market for some wines.", "default": "US" }, "currencyCode": { "title": "Currency", "enum": [ "USD", "GBP", "EUR", "CHF", "SEK", "DKK", "CAD", "AUD", "NZD", "JPY", "HKD", "SGD", "BRL", "MXN", "ZAR" ], "type": "string", "description": "Currency for wine prices (ISO 4217).", "default": "USD" } } }, "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 } } } } } } } } } } ```