# Whiskyfass.de Whisky Scraper (`scrapyspider/whiskyfass-data-scraper`) Actor

Scrapes 40+ fields per whisky product from whiskyfass.de — Germany's leading whisky retailer. Extracts pricing, ABV, age, cask type, tasting notes, distillery, region, and availability. Fast HTTP crawler, no login required.

- **URL**: https://apify.com/scrapyspider/whiskyfass-data-scraper.md
- **Developed by:** [ScrapySpider](https://apify.com/scrapyspider) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Whiskyfass.de Data Scraper + Shopify Integration 🥃 → 🛒

This Actor scrapes comprehensive whisky product data from [whiskyfass.de](https://whiskyfass.de), a German whisky retailer, and **optionally syncs products directly to your Shopify store via the Admin API**.

### 🆕 Shopify Integration Features

✅ **Automatic Product Creation** - Scraped products are automatically created in Shopify  
✅ **Smart Updates** - Updates existing products by SKU (no duplicates)  
✅ **Inventory Management** - Sets inventory levels automatically  
✅ **Product Mapping** - Maps whisky data to Shopify format (prices, images, tags)  
✅ **Error Handling** - Graceful error recovery with detailed sync reports  
✅ **Flexible Modes** - Create-only, update-only, or upsert (create or update)

### Features

- **Comprehensive Product Data** - Extracts 40+ fields per product including pricing, availability, images, and metadata
- **Tasting Notes Extraction** - Intelligent parser for nose, palate, finish, and appearance descriptions with flavor descriptors
- **Multi-language Support** - Handles both German and English content with language detection
- **Smart Data Normalization** - Converts units (ml, cl, l), normalizes ABV percentages, and standardizes pricing
- **Flavor Pattern Detection** - Uses regex patterns to identify 100+ flavor keywords across fruits, spices, wood, and more

### 🚀 Quick Start with Shopify

#### 1. Create Shopify Custom App

1. Go to Shopify Admin → **Settings** → **Apps and sales channels**
2. Click **"Develop apps"** → **"Create an app"**
3. Enable these API scopes: `write_products`, `read_products`, `write_inventory`, `read_inventory`
4. Install the app and copy your **Admin API Access Token**

#### 2. Test Your Connection

Edit [test-shopify.js](test-shopify.js) with your credentials and run:

```bash
node test-shopify.js
````

This will verify your connection and create/delete a test product.

#### 3. Run with Shopify Enabled

```bash
apify run --input '{
  "startUrls": [{"url": "https://whiskyfass.de/whisky"}],
  "enableShopify": true,
  "shopifyShopName": "your-store.myshopify.com",
  "shopifyAccessToken": "shpat_xxxxx",
  "shopifyAction": "upsert"
}'
```

📖 **Detailed guide:** See [stratgy.md](stratgy.md) for complete Shopify documentation.

### Technical Stack

- **[BasicCrawler](https://crawlee.dev/api/core/class/BasicCrawler)** - HTTP-based crawler using axios + Cheerio for fast static HTML parsing
- **[Cheerio](https://cheerio.js.org/)** - Fast, flexible HTML parsing library (jQuery-like API)
- **[Router Pattern](https://crawlee.dev/api/core/function/createBasicRouter)** - Organized request handling with labeled routes
- **[Apify SDK](https://docs.apify.com/sdk/js/)** - Dataset storage and Actor lifecycle management
- **[Input Schema](https://docs.apify.com/platform/actors/development/input-schema)** - Validated Actor configuration

### How it works

#### 1. Input Configuration

The Actor accepts `startUrls` array (defaults to `https://whiskyfass.de/whisky`) and begins crawling from the main whisky category page.

#### 2. Three-Stage Crawling Process

##### Stage 1: Category Discovery (Default Handler)

- Fetches the main whisky page
- Extracts subcategory links from the navigation menu
- Enqueues all subcategory URLs with label `'products'`

##### Stage 2: Product Listing Pages (Products Handler)

- Processes each subcategory page
- Extracts all product links from the listing
- Handles pagination to capture all products
- Enqueues product detail URLs with label `'detail'`

##### Stage 3: Product Detail Extraction (Detail Handler)

- Fetches and parses individual product pages
- Extracts 40+ fields including:
  - **Basic Info**: Name, brand, description, breadcrumbs, images
  - **Pricing**: Current price, old price, price per liter, currency
  - **Product Details**: EAN/SKU, bottle size, ABV, availability
  - **Whisky Specs**: Age, distillery, bottler, region, country, spirit type
  - **Maturation**: Cask type, cask finish, cask strength, chill filtration status
    -Project Structure

```
src/
├── main.js          ## Actor entry point, crawler initialization
├── routes.js        ## Router with 3 handlers (category, products, detail)
├── helpers.js       ## Data extraction & normalization utilities (675 lines)
├── selectors.js     ## CSS selectors for page elements
└── flavor.js        ## Regex patterns for flavor keyword detection
.actor/
├── actor.json       ## Actor metadata and configuration
└── input_schema.json ## Input validation schema
```

### Output Schema

Each product record contains these fields:

#### Prerequisites

- Node.js 18+ installed
- Apify CLI installed (`npm install -g apify-cli`)

#### Local Development

1. Install dependencies:

```bash
npm install
```

2. Run the Actor locally:

```bash
apify run
```

3. Configure input in `storage/key_value_stores/default/INPUT.json`:

```json
{
  "startUrls": [
    { "url": "https://whiskyfass.de/whisky" }
  ]
}
```

4. View results in \`storage/datasets/default/product\_url: "https://whiskyfass.de/...",
   canonical\_url: "https://whiskyfass.de/...",
   subcategory\_url: "https://whiskyfass.de/category",

// Identifiers
product\_id: "4012345678901", // EAN or URL hash
shop\_sku: "12345",

// Basic Info
name: "Glenfiddich 12 Year Old",
brand: "Glenfiddich",
description: "...",
breadcrumbs: \["Whisky", "Scotch", "Single Malt"],

// Images
main\_image: "https://...",
images: \["https://...", "https://..."],

// Pricing & Availability
price\_current: 39.90,
price\_old: 45.00,
price\_per\_liter: 57.00,
currency: "EUR",
availability\_enum: "in\_stock",

// Product Specs
bottle\_size\_ml: 700,
abv\_percent: 40.0,
age\_years: 12,
cask\_strength: false,
non\_chill\_filtered: true,

// Origin & Classification
distillery: "Glenfiddich",
country: "Scotland",
region: "Speyside",
spirit\_type: "Single Malt Whisky",

// Maturation
cask\_type: "Ex-Bourbon & Sherry Casks",

// Tasting Notes
nose: "Fresh pear, subtle oak...",
palate: "Creamy with notes of...",
finish: "Long and smooth...",
nose\_descriptors: \["pear", "oak", "vanilla"],
palate\_descriptors: \["cream", "malt", "spice"],
tasting\_notes\_confidence: 1.0,

// Metadata
timestamp\_utc: "2026-02-15T10:30:00.000Z",
scrape\_run\_id: "abc123"
}

```

### Resources

- [Crawlee + Apify Platform guide](https://crawlee.dev/docs/guides/apify-platform)
- [BasicCrawler Documentation](https://crawlee.dev/api/core/class/BasicCrawler)
- [Cheerio Documentation](https://cheerio.js.org/)
- [Apify SDK for JavaScript](https://docs.apify.com/sdk/js)
- [Node.js tutorials](https://docs.apify.com/academy/node-js) in Academy
// Detects and extracts structured tasting notes
nose: "Fresh citrus, vanilla, light oak"
palate: "Honey sweetness, spice notes, dried fruits"
finish: "Long and warming with hints of smoke"

// Auto-extracts flavor keywords
nose_descriptors: ["citrus", "vanilla", "oak"]
```

##### Flavor Pattern Detection

The Actor uses regex patterns in [flavor.js](src/flavor.js) to identify 100+ flavor keywords across categories:

- Fruits (citrus, apple, berry, etc.)
- Spices (vanilla, cinnamon, pepper, etc.)
- Sweet notes (honey, caramel, chocolate, etc.)
- Wood & smoke (oak, peat, etc.)
- Nuts & grains
- Floral & fresh notes

### Resources

If you're looking for examples or want to learn more visit:

- [Crawlee + Apify Platform guide](https://crawlee.dev/docs/guides/apify-platform)
- [Documentation](https://crawlee.dev/api/playwright-crawler/class/PlaywrightCrawler) and [examples](https://crawlee.dev/docs/examples/playwright-crawler)
- [Node.js tutorials](https://docs.apify.com/academy/node-js) in Academy
- [How to scale Puppeteer and Playwright](https://blog.apify.com/how-to-scale-puppeteer-and-playwright/)
- [Video guide on getting data using Apify API](https://www.youtube.com/watch?v=ViYYDHSBAKM)
- [Integration with Make](https://apify.com/integrations), GitHub, Zapier, Google Drive, and other apps
- A short guide on how to create Actors using code templates:

[web scraper template](https://www.youtube.com/watch?v=u-i-Korzf8w)

### Getting started

For complete information [see this article](https://docs.apify.com/platform/actors/development#build-actor-locally). To run the Actor use the following command:

```bash
apify run
```

### Deploy to Apify Platform

#### Option 1: Deploy from Local Machine

1. Log in to Apify (requires [API Token](https://console.apify.com/account/integrations)):

```bash
apify login
```

2. Deploy your Actor:

```bash
apify push
```

Your Actor will be built and deployed to [Actors -> My Actors](https://console.apify.com/actors?tab=my).

#### Option 2: Connect Git Repository

1. Go to [Actor creation page](https://console.apify.com/actors/new)
2. Click **Link Git Repository**
3. Connect your repository and configure build settings

### Configuration

#### Input Parameters

```json
{
  "startUrls": [
    { "url": "https://whiskyfass.de/whisky" }
  ]
}
```

- `startUrls` (required): Array of URLs to start crawling from. Defaults to the main whisky category page.

#### Crawler Settings

Configured in [main.js](src/main.js):

- `maxConcurrency: 5` - Maximum parallel requests
- Uses BasicCrawler with axios for HTTP requests (no browser needed)

#### Selectors

All CSS selectors are defined in [selectors.js](src/selectors.js). Update these if the website structure changes.

### Maintenance

#### Updating Flavor Patterns

Edit [flavor.js](src/flavor.js) to add or modify flavor detection keywords:

```javascript
export const flavorPatterns = [
    // Add new patterns
    /\b(your|new|keywords)\b/gi,
];
```

#### Updating Selectors

If the website HTML structure changes, update [selectors.js](src/selectors.js):

```javascript
export const selectors = {
    detail: {
        productTitle: 'h1.product-title',  // Update selectors here
        price: '[class*="price h3"]',
        // ...
    }
};
```

### Troubleshooting

#### No products found

- Check if website structure has changed
- Verify selectors in `selectors.js`
- Check logs for HTTP errors or blocked requests

#### Missing tasting notes

- Verify the product page has tasting note sections
- Check `tasting_notes_confidence` field (1.0 = high confidence, 0.3 = ambiguous)
- Some products may not have detailed tasting notes

#### Incorrect data extraction

- Review helper functions in `helpers.js`
- Check regex patterns for units, prices, and ABV
- Verify language detection is working correctly

### Performance Notes

- **Speed**: BasicCrawler with Cheerio is ~10x faster than browser-based crawlers for static HTML
- **Efficiency**: No browser automation overhead, uses simple HTTP requests
- **Concurrency**: Set to 5 parallel requests for optimal balance between speed and server load
- **Resource Usage**: Minimal memory and CPU usage compared to Puppeteer/Playwright

### License

ISC

### Author

It's not you it's me

# Actor input Schema

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

URLs to start scraping from.

## `maxRequestsPerCrawl` (type: `integer`):

Maximum number of pages to scrape (0 = unlimited)

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://whiskyfass.de/whisky"
    }
  ],
  "maxRequestsPerCrawl": 100
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://whiskyfass.de/whisky"
        }
    ],
    "maxRequestsPerCrawl": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapyspider/whiskyfass-data-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://whiskyfass.de/whisky" }],
    "maxRequestsPerCrawl": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapyspider/whiskyfass-data-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://whiskyfass.de/whisky"
    }
  ],
  "maxRequestsPerCrawl": 100
}' |
apify call scrapyspider/whiskyfass-data-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Whiskyfass.de Whisky Scraper",
        "description": "Scrapes 40+ fields per whisky product from whiskyfass.de — Germany's leading whisky retailer. Extracts pricing, ABV, age, cask type, tasting notes, distillery, region, and availability. Fast HTTP crawler, no login required.",
        "version": "1.0",
        "x-build-id": "8YNiIEEqCcTEBVlGH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapyspider~whiskyfass-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapyspider-whiskyfass-data-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapyspider~whiskyfass-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapyspider-whiskyfass-data-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapyspider~whiskyfass-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapyspider-whiskyfass-data-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "URLs to start scraping from.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Max Requests Per Crawl",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of pages to scrape (0 = unlimited)",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```