# James Suckling Wine Scraper - Scores & Drink Windows (`growth-installations/jamessuckling-scraper`) Actor

Scrape jamessuckling.com's tasting-report archive for wine reviews: producer, wine name, vintage, region, appellation, James Suckling 100-point score, drinking window, publish date and note snippet. Extracts public review data from top-100 lists, weekly reports, and en primeur roundups.

- **URL**: https://apify.com/growth-installations/jamessuckling-scraper.md
- **Developed by:** [Growth Installations](https://apify.com/growth-installations) (community)
- **Categories:** Lead generation, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 wine reviews

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

## James Suckling Wine Scraper - Scores & Drink Windows

Scrape jamessuckling.com's tasting-report archive for wine reviews: producer, wine name, vintage, region, appellation, James Suckling 100-point score, drinking window, publish date and note snippet. Extracts public review data from top-100 lists, weekly reports, and en primeur roundups.

Built for wine importers, restaurant beverage directors, wine retailers, sommeliers, wine journalists, fine-wine investors.

### What this jamessuckling.com scraper extracts

Every run produces one row per record, with change annotations against your last snapshot, with the following fields:

- **report_url** (string), Editorial report the wine card was extracted from
- **report_title** (string)
- **rank** (integer), Position within the report (1 = top of list)
- **full_name** (string), Full "Producer + Wine + Region + Vintage" string as displayed
- **producer** (string), Producer name split from full_name using variety-keyword heuristic
- **wine_name** (string), Variety + specific bottling (e.g. "Chardonnay Napa Valley Hyde Vineyard")
- **vintage** (string)
- **region** (string)
- **country** (string)
- **appellation** (string)
- **grape_variety** (string)
- **color** (string), Red, White, Rose, Sparkling, Fortified
- **suckling_score** (integer), 100-point scale
- **drinking_window** (string), e.g. 2024-2039 — extracted from tasting note text when present
- **tasting_note_snippet** (string), First 200 chars of the tasting note (full note is subscriber-only)
- **tasting_date** (string)
- **price_at_review** (number)
- **value_flag** (boolean), True when James Suckling flags the wine as a "great value"


### Quick start

1. Click **Try for free**.
2. Leave the input at defaults, or paste the recommended input from lower on this page.
3. Click **Start**. The default run finishes in under a minute with a small sample.
4. Open the **Dataset** tab to inspect the shape.
5. Once you like the output, click **Schedule** and pick a cadence. Daily is typical.

### How a run works

1. **Scan**, walks jamessuckling.com from the seed URL, paginating through list pages.
2. **Fetch**, visits each detail page and extracts the fields listed above.
3. **Diff**, compares each record against the snapshot in your named key-value store, labelling it `new`, `changed` or `unchanged`.
4. **Persist**, the new snapshot is saved for the next run.

#### What is a delta feed and why does it save money?

A delta feed only pays for what changed since your last run. Instead of re-scraping every record each night, this scraper compares against your stored snapshot and only fully processes rows that added, changed or first appeared. Enable `onlyChanged` to skip unchanged rows entirely (they are billed at a discounted rate).

#### What differentiates this scraper?

Direct scraping of Suckling scores + drinking windows is uniquely valuable because Parker + Wine Spectator require paid subscriptions. Vivino covers consumer ratings, not critic scores. James Suckling scores drive premium wine pricing in Asia and US retail; retailers cite them in catalogs (LCBO, Sydney Cellars, Skurnik) daily.

### Common use cases

- Weekly refresh of top-scoring wines by region for retailer buying
- Vintage comparison across producers within an appellation
- Drinking-window inventory management for wine cellars
- Suckling score alerts on Bordeaux, Napa, Barolo en primeur releases
- James Suckling top-100 list capture for annual buying guides


### How to interpret the fields

#### What does James Suckling score mean?

On the standard 100-point wine rating scale. 95+ is a benchmark for buying committees. 100 is perfect and extremely rare (maybe 1-2 wines per year). 90-94 is the sweet spot for restaurant lists and retail; 85-89 is the value-tier for daily-drinking wines.

#### What does Great value flag mean?

James Suckling personally tags a subset of high-scoring wines as "great value" when the price-to-quality ratio is exceptional. Useful for retailers building an under-$30 top-of-list section.

#### What does Barrel-sample vs bottled scores mean?

En primeur reviews (published before bottling) sometimes score as a range (e.g. 94-96) indicating uncertainty. Post-bottling reviews score as a single number. Retailer buyers weight bottled scores more heavily.



### How this compares to alternative scrapers

#### James Suckling scraper vs Vivino API

Vivino aggregates consumer ratings, not critic scores. Different signal: crowd-taste vs professional-palate. Retailers use Vivino for consumer-facing shelf-talkers and Suckling for buying committee decisions.

#### James Suckling scraper vs Wine Spectator or Robert Parker

Wine Spectator and Robert Parker require paid subscriptions to access scores in bulk. James Suckling exposes scores in editorial reports for free. This makes JS the only major critic scrapeable at scale without subscriber credentials.

#### James Suckling scraper vs the WineSearcher price feed

WineSearcher aggregates retail prices, not critic scores. Complementary: run WineSearcher for pricing, this scraper for scores, join on producer + wine name + vintage for a complete competitive-shelf record.



### How much does it cost to scrape jamessuckling.com?

Pay-per-event pricing:

- **Actor start**: $0.00500 per GB of memory, one event per run.
- **Wine review**: $0.00300 per record delivered to the dataset.
- **Wine checked, unchanged**: $0.00080 per row when `onlyChanged` is on and the row was unchanged. Roughly 27% the cost of a full record.

There are no per-request charges and no page-count charges. Costs come only from records you actually receive. A scheduled monitor in delta mode typically costs cents per day; a first-time full crawl is the expensive case that the delta model is designed to avoid on subsequent runs.

#### Concrete cost examples

Rule-of-thumb cost per run (assumes primary event only, no delta discount):

- **100 records** = about $0.30 in records + one actor-start fee
- **500 records** = about $1.50
- **1,000 records** = about $3.00
- **10,000 records** = about $30.00

With delta mode + `onlyChanged: true`, a daily monitor of 1,000 properties where 5% change costs roughly **$0.91 per run** (50 full charges + 950 delta-priced skips).

### Common questions

#### Does this scraper need a James Suckling subscription?

No. This scraper extracts public data from editorial tasting reports (top-100 lists, weekly reports, en primeur roundups). Full tasting notes are subscriber-gated but scores, drinking windows, and producer/vintage/region are public.

#### What is a Suckling score?

James Suckling uses the standard 100-point wine rating scale (originally popularized by Robert Parker). 95+ is exceptional; 90-94 is outstanding; 85-89 is very good; below 85 is skip-worthy for premium buyers. Ranges (e.g. 92-93) indicate barrel samples or en primeur ratings before final blending.

#### What is a drinking window?

The recommended range of years the wine should be consumed for peak enjoyment. Typically expressed as YYYY-YYYY. Wines drunk before window may lack complexity; wines drunk after may be past-prime. Useful for cellar-management buyers.

#### How many wine reviews are covered?

Editorial reports cover roughly 30,000-50,000 wine cards per year across 500+ published reports. Historical archive extends back multiple years.

#### Are en primeur wines included?

Yes. Bordeaux, Rhone, and Burgundy en primeur reports are published annually and picked up on the next scheduled scrape.

#### What about the full tasting note?

The full note (typically 3-5 sentences) is subscriber-only. This scraper captures a public snippet (first ~200 characters) alongside the score, window, producer, vintage and region.

#### Does this scraper need an account with jamessuckling.com?

No. The scraper reads only public pages. You do not need credentials.

#### Why do I need to enable Apify Proxy?

Most sites at scale trigger rate limits or challenges against datacenter IPs. Apify Proxy (residential recommended) handles this. The default input keeps `useApifyProxy: true`.

#### Why does the state store need a name?

Delta mode compares each run against the previous snapshot. Apify wipes the default (unnamed) key-value store on every run, which would erase the snapshot. A NAMED store (`stateStoreName: "jamessuckling-scraper-state"`) persists across runs.

#### Can I run in delta mode without paying for unchanged rows?

Yes. Set `onlyChanged: true`. Unchanged rows are billed at the discounted `record-checked` rate; changed rows at the full `wine` rate. New rows are always full price.

### Recommended daily-schedule input

```json
{
  "maxItems": 5,
  "maxReports": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

For a full-catalogue first run, raise `maxItems` to `0` (no cap) and leave `onlyChanged: false`. For daily monitoring, set `onlyChanged: true` and keep `maxItems` at `0`.

### Turn it into a live alert with Schedules and Webhooks

Combine this scraper with an Apify **Schedule** and a **Webhook** to get "new listing in my buy box" alerts without writing code.

1. Configure the input with your buy-box filters (yield floor, price ceiling, markets, etc).
2. Create a Schedule (Actor page, right rail, Schedule) at your cadence. Daily 06:00 UTC is typical.
3. Add a Webhook (Integrations tab on this actor):
   - Event: `ACTOR.RUN.SUCCEEDED`
   - URL: your Slack / Discord / Zapier / n8n endpoint
   - Payload template: pass `resource.defaultDatasetId` so the receiver can pull only the delta rows

For Slack, wrap the payload in a `text` field and push through an [incoming webhook](https://api.slack.com/messaging/webhooks). For Zapier or n8n, use the "Webhook by Apify" trigger and map dataset fields to your downstream tool of choice.

Pair this with `onlyChanged: true` and the actor becomes a pure alert feed. Delta-priced rows keep the bill flat on quiet days.

### Related scrapers from this publisher

See other actors under [growth-installations](https://apify.com/growth-installations) for related consumer-intelligence scrapers.

### Video walkthrough

Video walkthrough placeholder. Add a YouTube URL to `readme.video_url` in the yaml to auto-embed once one is published.

### Notes and limits

- Keep concurrency modest to stay polite to jamessuckling.com. Default is 5.
- Field schemas can shift when the target site restyles. If a field starts returning `null`, report it and it will be patched.
- The default input is engineered to complete in under 5 minutes so the platform's daily automated test passes and the actor does not get flagged for maintenance.

### Legal

Reads only public editorial tasting reports at /wine-tasting-reports/. Does NOT access the subscriber-only /winegalaxy or the JS-API-KEY-gated custom API. You are responsible for compliance with applicable law and jamessuckling.com's terms of service. If you extract subscriber content via account credentials, you accept the additional obligations of James Suckling's subscriber agreement.

# Actor input Schema

## `reportUrls` (type: `array`):

Specific /wine-tasting-reports/{slug} URLs to scrape. If empty, uses a default set of top-100 reports. The index page is client-rendered so URLs must be seeded directly.

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

Stop after this many wine cards. 0 = no cap.

## `maxReports` (type: `integer`):

Cap on report articles to process. 0 = all discovered.

## `onlyChanged` (type: `boolean`):

Delta mode (skip unchanged wine cards)

## `stateStoreName` (type: `string`):

State store name

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

Proxy

## `maxConcurrency` (type: `integer`):

Max concurrency

## `maxRequestRetries` (type: `integer`):

Max retries per request

## Actor input object example

```json
{
  "reportUrls": [],
  "maxItems": 5,
  "maxReports": 3,
  "onlyChanged": false,
  "stateStoreName": "jamessuckling-state",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 3,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `results` (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 = {
    "reportUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("growth-installations/jamessuckling-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 = { "reportUrls": [] }

# Run the Actor and wait for it to finish
run = client.actor("growth-installations/jamessuckling-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 '{
  "reportUrls": []
}' |
apify call growth-installations/jamessuckling-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=growth-installations/jamessuckling-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "James Suckling Wine Scraper - Scores & Drink Windows",
        "description": "Scrape jamessuckling.com's tasting-report archive for wine reviews: producer, wine name, vintage, region, appellation, James Suckling 100-point score, drinking window, publish date and note snippet. Extracts public review data from top-100 lists, weekly reports, and en primeur roundups.",
        "version": "0.0",
        "x-build-id": "9jhJP3wlufRtccEme"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/growth-installations~jamessuckling-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-growth-installations-jamessuckling-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/growth-installations~jamessuckling-scraper/runs": {
            "post": {
                "operationId": "runs-sync-growth-installations-jamessuckling-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/growth-installations~jamessuckling-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-growth-installations-jamessuckling-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": {
                    "reportUrls": {
                        "title": "Report URLs (optional)",
                        "type": "array",
                        "description": "Specific /wine-tasting-reports/{slug} URLs to scrape. If empty, uses a default set of top-100 reports. The index page is client-rendered so URLs must be seeded directly.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum wines to push",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many wine cards. 0 = no cap.",
                        "default": 5
                    },
                    "maxReports": {
                        "title": "Maximum tasting reports to walk",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on report articles to process. 0 = all discovered.",
                        "default": 3
                    },
                    "onlyChanged": {
                        "title": "Delta mode (skip unchanged wine cards)",
                        "type": "boolean",
                        "description": "Delta mode (skip unchanged wine cards)",
                        "default": false
                    },
                    "stateStoreName": {
                        "title": "State store name",
                        "type": "string",
                        "description": "State store name",
                        "default": "jamessuckling-state"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Max concurrency",
                        "default": 3
                    },
                    "maxRequestRetries": {
                        "title": "Max retries per request",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Max retries per request",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
