# K-Rauta Scraper — Finnish Hardware & Building Materials (`studio-amba/krauta-scraper`) Actor

Scrape products from K-Rauta.fi, a Finnish hardware and building materials retailer. Tools, construction supplies, and renovation products.

- **URL**: https://apify.com/studio-amba/krauta-scraper.md
- **Developed by:** [Jelle Desramaults](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## K-Rauta Scraper

Extract product data, prices, stock status, and reviews from k-rauta.fi -- Finland's major hardware and building materials retailer. Covers paint, tools, building supplies, plumbing, electrical, garden equipment, and everything Finnish renovators need.

### What is K-Rauta Scraper?

K-Rauta is Finland's leading DIY and hardware retail chain, part of the Kesko Group -- one of the largest retail conglomerates in Northern Europe. K-Rauta stores serve both consumers and professional builders with a comprehensive range of building materials, tools, paints, plumbing, and electrical supplies. The brand has deep roots in Finnish construction culture, stocking everything from Tikkurila paints to structural timber and insulation.

This scraper extracts structured product data from their Finnish website. Here is how people use it:

- **Finnish building material pricing** -- K-Rauta is the benchmark retailer for construction costs in Finland. Track prices on insulation, timber, concrete, and roofing to understand Finnish building economics
- **Nordic cross-border comparison** -- Compare K-Rauta's Finnish prices (in EUR) against Swedish retailers (Byggmax in SEK, Jula in SEK) and German hardware stores (Hagebau, Bauhaus in EUR). Since Finland uses EUR, direct price comparison with French and German retailers is straightforward
- **Paint market intelligence** -- Finland has a strong domestic paint industry led by Tikkurila. Track retail pricing on paints, stains, and coatings at K-Rauta versus competitors
- **Professional builder sourcing** -- Extract bulk pricing data on construction staples: plywood, gypsum board, insulation, screws, and piping to optimize procurement across suppliers
- **Seasonal demand tracking** -- Monitor Finnish DIY seasonality: spring building materials boom, summer garden equipment, autumn heating season, and winter interior renovation

### What data does K-Rauta Scraper extract?

Each product includes these fields when available:

- 🏷️ **Product name** -- Full title in Finnish
- 🏢 **Brand** -- Manufacturer name
- 💰 **Price** -- Current price in EUR
- 🔖 **Original price** -- Pre-discount price for sale items
- 🆔 **Product ID** -- K-Rauta product identifier from URL
- 📦 **In stock** -- Availability (detects Finnish keywords: "varastossa", "saatavilla")
- ⭐ **Rating** -- Customer rating
- 💬 **Review count** -- Number of reviews
- 🖼️ **Image URL** -- Main product image
- 📝 **Description** -- Product description from meta tags
- 📂 **Category** -- Product category from breadcrumbs
- 🔗 **EAN** -- European Article Number (barcode)

### How to scrape K-Rauta

#### Search by keyword

```json
{
    "searchQuery": "maali",
    "maxResults": 100
}
````

Good Finnish search terms: `"maali"` (paint), `"porakone"` (drill), `"ruuvi"` (screw), `"eriste"` (insulation), `"laminaatti"` (laminate), `"hana"` (faucet), `"työvalo"` (work light), `"laatta"` (tile), `"tapetti"` (wallpaper).

#### Scrape a category

```json
{
    "categoryUrl": "https://www.k-rauta.fi/tuotteet/tyokalut",
    "maxResults": 500
}
```

#### Input reference

| Field | Type | Description |
|-------|------|-------------|
| `categoryUrl` | String | K-rauta.fi category page URL |
| `searchQuery` | String | Finnish keyword (default: `"maali"`) |
| `maxResults` | Integer | Product limit (default: 100, max: 10,000) |
| `proxyConfiguration` | Object | Proxy settings (Apify proxy recommended) |

**Tip:** K-Rauta uses Finnish product URLs with the `/tuote/` (product) path pattern. The scraper first visits listing pages to collect product links, then visits each detail page for full data extraction. Use Finnish search terms for best results.

### Output

```json
[
    {
        "name": "Tikkurila Harmony sisämaali 2,7L valkoinen",
        "brand": "Tikkurila",
        "price": 34.90,
        "currency": "EUR",
        "originalPrice": 42.90,
        "productId": "6408070012345",
        "inStock": true,
        "rating": 4.5,
        "reviewCount": 89,
        "imageUrl": "https://www.k-rauta.fi/media/products/tikkurila-harmony-2-7l.jpg",
        "description": "Hajuton ja paastoton sisämaali seinille ja katoille. Taysin himea. Soveltuu olohuoneisiin, makuuhuoneisiin ja lastenhuoneisiin.",
        "category": "Maalit ja tarvikkeet",
        "ean": "6408070012345",
        "url": "https://www.k-rauta.fi/tuote/tikkurila-harmony-sisamaali-2-7l-valkoinen/6408070012345",
        "scrapedAt": "2026-04-03T13:00:00.000Z"
    },
    {
        "name": "Makita poravasara HR2470 780W SDS-Plus",
        "brand": "Makita",
        "price": 189.00,
        "currency": "EUR",
        "inStock": true,
        "rating": 4.7,
        "reviewCount": 56,
        "imageUrl": "https://www.k-rauta.fi/media/products/makita-hr2470.jpg",
        "description": "Tehokas poravasara ammattilaiskayttoon. 780W moottori, 2,4 J iskuenergia. SDS-Plus istukka. Nopea poranterän vaihto.",
        "category": "Sähkötyökalut",
        "url": "https://www.k-rauta.fi/tuote/makita-poravasara-hr2470-780w/4567890",
        "scrapedAt": "2026-04-03T13:00:14.000Z"
    },
    {
        "name": "Paroc eXtra vuorivilla 100mm 565x1170",
        "brand": "Paroc",
        "price": 24.90,
        "currency": "EUR",
        "inStock": true,
        "imageUrl": "https://www.k-rauta.fi/media/products/paroc-extra-100mm.jpg",
        "description": "Yleiseriste seiniin, lattiaan ja ylapohjaaan. Lambda 0,036 W/mK. Paketti 8,59 m2. A1-paloluokitus.",
        "category": "Eristeet",
        "ean": "6418091452345",
        "url": "https://www.k-rauta.fi/tuote/paroc-extra-vuorivilla-100mm/6418091452345",
        "scrapedAt": "2026-04-03T13:00:28.000Z"
    }
]
```

Export in **JSON**, **CSV**, **Excel**, **XML**, or **RSS**.

### How much does it cost?

K-Rauta Scraper uses CheerioCrawler (HTTP-only, no browser).

| Scenario | Products | Estimated cost |
|----------|----------|----------------|
| Quick search | 50 | ~$0.03 |
| Category scan | 200 | ~$0.10 |
| Multi-category export | 1,000 | ~$0.50 |
| Large catalog crawl | 5,000 | ~$2.50 |

The Apify free tier covers regular monitoring runs. Each product detail page is visited individually, so costs scale linearly with volume.

### Can I integrate?

Connect K-Rauta data to your workflow:

- **Webhooks** -- Trigger actions on scrape completion
- **Google Sheets** -- Auto-export Finnish product data to spreadsheets
- **Slack / Microsoft Teams** -- Price alerts and stock change notifications
- **Zapier / Make** -- Connect to 5,000+ apps
- **Amazon S3 / Google Cloud** -- Cloud storage for data pipelines
- **PostgreSQL / MySQL** -- Direct database ingestion
- **API** -- Full programmatic access

### Can I use it as an API?

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/krauta-scraper").call(run_input={
    "searchQuery": "porakone",
    "maxResults": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['name']} - EUR {item['price']}")
```

#### JavaScript

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

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/krauta-scraper").call({
    searchQuery: "porakone",
    maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => console.log(`${item.name} - EUR ${item.price}`));
```

### FAQ

**Why is K-Rauta valuable for European price comparison?**
K-Rauta prices are in EUR, making direct comparison with French (Leroy Merlin, Brico Depot) and German (OBI, Hornbach) retailers straightforward -- no currency conversion needed. Since Finland is a smaller market, products can be priced differently than in larger EUR-zone countries.

**What makes K-Rauta different from Byggmax or Jula?**
K-Rauta is a full-service Finnish hardware store comparable to OBI or Leroy Merlin. Byggmax is a Swedish budget building materials chain (limited service, lower prices). Jula focuses on tools and outdoor gear. K-Rauta's catalog is broader and includes professional building materials, bathroom fixtures, and kitchen fittings that the others do not carry.

**Does the scraper understand Finnish stock status?**
Yes. It detects Finnish availability keywords: "varastossa" (in stock), "saatavilla" (available), and "myymälässä" (in store). These are mapped to a boolean `inStock` field.

**Can I track Tikkurila paint prices?**
Absolutely. Tikkurila is Finland's leading paint brand and K-Rauta is their primary retail channel. Search for `"tikkurila"` or specific product lines like `"harmony"` or `"joker"` to track the Finnish paint market.

**Are there EAN barcodes for cross-retailer matching?**
Yes, when available on the product page. EANs are extracted from schema.org microdata (`gtin13` or `ean` properties). Use these to match identical products across K-Rauta, Clas Ohlson (Finland market), and other European retailers.

**How does pagination work?**
The scraper follows `rel="next"` links and Finnish-language "Seuraava" (next) buttons. It collects all product links from listing pages before visiting individual detail pages.

### Limitations

- All data is in Finnish from k-rauta.fi
- Each product detail page is visited individually, so larger scrapes take proportionally more time
- Stock detection is based on keyword matching in Finnish -- some products may not have clear availability indicators
- Product description is extracted from meta tags and may be shorter than the full page description
- Pagination relies on standard next-page link patterns; some category structures may not paginate as expected
- The scraper does not capture store-specific stock levels or local pricing

### Other DIY & hardware scrapers

Build Nordic and European hardware market intelligence by combining these scrapers:

- [Gamma Scraper](https://apify.com/studio-amba/gamma-scraper) -- Netherlands
- [Leroy Merlin Scraper](https://apify.com/studio-amba/leroymerlin-scraper) -- France
- [Brico Scraper](https://apify.com/studio-amba/brico-scraper) -- Belgium
- [Praxis Scraper](https://apify.com/studio-amba/praxis-scraper) -- Netherlands
- [OBI Scraper](https://apify.com/studio-amba/obi-scraper) -- Germany
- [Hornbach Scraper](https://apify.com/studio-amba/hornbach-scraper) -- Germany/Europe
- [Bauhaus Scraper](https://apify.com/studio-amba/bauhaus-scraper) -- Germany/Europe
- [Castorama Scraper](https://apify.com/studio-amba/castorama-scraper) -- France/Poland
- [Hubo Scraper](https://apify.com/studio-amba/hubo-scraper) -- Belgium/Netherlands
- [Toom Scraper](https://apify.com/studio-amba/toom-scraper) -- Germany
- [Hagebau Scraper](https://apify.com/studio-amba/hagebau-scraper) -- Germany
- [Globus Baumarkt Scraper](https://apify.com/studio-amba/globus-baumarkt-scraper) -- Germany
- [Bricorama Scraper](https://apify.com/studio-amba/bricorama-scraper) -- France
- [Brico Depot Scraper](https://apify.com/studio-amba/bricodepot-scraper) -- France
- [Byggmax Scraper](https://apify.com/studio-amba/byggmax-scraper) -- Sweden
- [Bricomarche Scraper](https://apify.com/studio-amba/bricomarche-scraper) -- France
- [Clas Ohlson Scraper](https://apify.com/studio-amba/clasohlson-scraper) -- Scandinavia
- [Jula Scraper](https://apify.com/studio-amba/jula-scraper) -- Sweden

### Your feedback

We maintain this scraper actively. If you find issues, want new fields, or have suggestions for improving Finnish DIY data extraction, reach out through the actor's Apify Store page or the community forum.

# Actor input Schema

## `categoryUrl` (type: `string`):

URL of a category page to scrape

## `searchQuery` (type: `string`):

Search term to find products

## `maxResults` (type: `integer`):

Maximum number of results

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

Apify proxy settings

## Actor input object example

```json
{
  "searchQuery": "maali",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/krauta-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/krauta-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 '{}' |
apify call studio-amba/krauta-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "K-Rauta Scraper — Finnish Hardware & Building Materials",
        "description": "Scrape products from K-Rauta.fi, a Finnish hardware and building materials retailer. Tools, construction supplies, and renovation products.",
        "version": "0.1",
        "x-build-id": "BhTmEKanJ45Yq2enh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~krauta-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-krauta-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/studio-amba~krauta-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-krauta-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/studio-amba~krauta-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-krauta-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": {
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "URL of a category page to scrape"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term to find products",
                        "default": "maali"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of results",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy settings",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
