# MCS Certified Products Scraper (`morkerr/mcscertified-com-product-scraper`) Actor

Scrape 260,000+ MCS certified renewable energy products from the official UK scheme directory. Extract certification numbers, manufacturers, model numbers, technology types, SCOP data, and certification details across 12 categories including solar PV, heat pumps, biomass.

- **URL**: https://apify.com/morkerr/mcscertified-com-product-scraper.md
- **Developed by:** [morkerr](https://apify.com/morkerr) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## MCS Certified Products Scraper

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue)](https://console.apify.com/actors/PZEuyhPVmZSWlstFW)
[![Node.js](https://img.shields.io/badge/Node.js-20-green)](https://nodejs.org/)
[![License](https://img.shields.io/badge/License-ISC-lightgrey)]()

Scrape certified renewable energy product data from **mcscertified.com/product-directory/** — the official UK registry of MCS (Microgeneration Certification Scheme) certified products. This actor extracts detailed product specifications, certification information, manufacturer details, and technology performance data for over 260,000 renewable energy products across 12 technology categories.

---

### Use Cases

- **Solar PV Panel Database** — Build comprehensive product databases with peak power output, test conditions, and certification details for thousands of solar PV modules
- **Heat Pump Market Intelligence** — Extract SCOP (Seasonal Coefficient of Performance) data at multiple flow temperatures for air source, ground source, and exhaust air heat pumps
- **Manufacturer Product Audits** — Track all certified products from specific manufacturers across different technology categories
- **Certification Expiry Monitoring** — Identify products with expired or expiring certifications for compliance auditing
- **Renewable Energy Directories** — Generate structured product data for green energy comparison websites and installer tools
- **Supply Chain Analysis** — Analyze product distribution by manufacturer, technology type, certification body, and certification status
- **Technology Trend Research** — Study the evolution of certified products across solar, heat pump, biomass, and wind technology categories

### Features

- **12 Technology Categories** — Solar PV, Air Source Heat Pump, Ground/Water Source Heat Pump, Biomass, Solar Thermal, Wind Turbine, Micro CHP, Exhaust Air Heat Pump, Solar Assisted Heat Pump, and more
- **Technology Sub-Type Filtering** — Filter by Air-to-Air and Air-to-Water sub-types for heat pump products
- **Manufacturer Search** — Filter by manufacturer name with partial match support
- **Certification Status Filtering** — Toggle between Certified and Expired products
- **Date Range Filtering** — Filter products by certification period start and end dates
- **Full Product Details** — Product name, certification number, manufacturer, model number, certification body, technology type, peak power output, test conditions
- **SCOP Performance Data** — Extract Seasonal Coefficient of Performance at 35°C, 45°C, 55°C flow temperatures for heat pump products
- **Manufacturer Website Links** — Direct URLs to manufacturer product pages
- **Configurable Pagination** — Set results per page (30/60/90) and page limits for small test runs or full dataset extraction
- **Clean Structured Output** — JSON dataset with consistent field naming, SEO-friendly slugs, and ISO timestamps

### Input Options

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `search` | String | — | Search by product name or certification number |
| `sortBy` | Select | Default | Sort order: Date (New-Old), Date (Old-New), Title (A-Z), Title (Z-A) |
| `manufacturer` | String | — | Filter by manufacturer name (partial match) |
| `certificationStatus` | Multi-select | — | Filter by Certified or Expired status |
| `technologyTypes` | Multi-select | — | Filter by 12 renewable technology categories |
| `technologySubTypes` | Multi-select | — | Filter by Air-to-Air or Air-to-Water sub-types |
| `certifiedFrom` | String | — | Certification period start date (YYYY-MM-DD) |
| `certifiedTo` | String | — | Certification period end date (YYYY-MM-DD) |
| `resultsPerPage` | Integer | 30 | Results per page (30, 60, or 90) |
| `maxPages` | Integer | 1 | Maximum pages to scrape (0 = all 52,000+ pages) |

#### Available Technology Filters

| Value | Category |
|-------|----------|
| `Air Source Heat Pump` | Heat Pumps |
| `Biomass` | Biomass Boilers & Stoves |
| `Exhaust Air Heat Pump` | Heat Pumps |
| `Gas Absorbtion Heat Pump` | Heat Pumps |
| `Ground/Water Source Heat Pump` | Heat Pumps |
| `Micro CHP` | Micro Combined Heat & Power |
| `Solar Assisted Heat Pump` | Hybrid Solar & Heat Pump |
| `Solar Heating` | Solar Thermal Hot Water |
| `Solar Heating Mounting` | Solar Thermal Mounting Systems |
| `Solar PV` | Solar Photovoltaic Panels |
| `Solar PV Mounting` | Solar PV Mounting Systems |
| `Wind Turbine` | Small Wind Turbines |

### Output Fields

Each product record in the dataset includes:

| Field | Description |
|-------|-------------|
| `productName` | Product name/model |
| `slug` | URL-friendly product name slug |
| `url` | Deep link to product on mcscertified.com |
| `certificationNumber` | Unique MCS certification identifier |
| `manufacturer` | Product manufacturer name |
| `modelNumber` | Specific model number |
| `certificationBody` | Issuing certification body (e.g. BRE Global, HETAS, BABT/TUV) |
| `technology` | Renewable technology category |
| `technologySubType` | Technology sub-type (e.g. Air-to-Water) |
| `peakPowerOutput` | Peak power output rating (solar PV products) |
| `testConditions` | Standard test conditions for performance rating |
| `certificationPeriodFrom` | Certification period start date |
| `certificationPeriodTo` | Certification period end date |
| `certificationStatus` | Current certification status (Certified / Expired) |
| `scheme` | Certification scheme (typically MCS) |
| `website` | Manufacturer product website URL |
| `scopPerformance` | Array of SCOP values at different flow temperatures (heat pumps) |
| `mcsProductId` | Internal MCS product database ID |
| `scrapedAt` | ISO timestamp of when the record was scraped |

### How It Works

This actor communicates directly with the WordPress AJAX API that powers the mcscertified.com product directory search. It does NOT use a headless browser:

1. **Nonce Extraction** — Fetches the product directory page HTML to extract the WordPress AJAX nonce
2. **API Queries** — Sends structured GET requests to `admin-ajax.php?action=filter_products` with all filter parameters
3. **HTML Parsing** — Parses the API response HTML using regex to extract product tile data and associated detail modals
4. **SCOP Extraction** — For heat pump products, extracts SCOP performance data from the flow temperature performance table
5. **Dataset Output** — Each validated product record is pushed to the Apify dataset with all available fields

**No browser, no heavy dependencies.** The actor is fast (~1 second per page), lightweight (~60MB container), and highly reliable.

### Quick Start

1. Open the actor in Apify Console: [mcscertified-com-product-scraper](https://console.apify.com/actors/PZEuyhPVmZSWlstFW)
2. Click **Start** with default settings to scrape the first page of products
3. Or configure filters to narrow by technology type, manufacturer, or certification status
4. Increase `maxPages` to scrape more results (set to 0 for all 260,000+ products)
5. Export results as JSON, CSV, XML, or Excel

#### API Example

```javascript
const { ApifyClient } = require('apify-client');

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

// Scrape solar PV products from a specific manufacturer
const run = await client.actor('morkerr/mcscertified-com-product-scraper').call({
    technologyTypes: ['Solar PV'],
    manufacturer: 'Talesun',
    maxPages: 5,
    resultsPerPage: 30,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Extracted ${items.length} certified solar PV products`);
````

### Performance

- **Single page** (30 products): ~1 second
- **Full dataset** (260,000+ products, 52,000+ pages): estimated 14+ hours
- **Container size**: ~60MB (Node.js 20, no browser dependencies)
- **Memory usage**: ~80MB per page batch

### Limitations

- The MCS AJAX nonce has a limited lifetime; the actor extracts a fresh nonce at the start of each run
- The API returns a maximum of 90 results per page
- SCOP data is only available for heat pump products with a flow temperature performance table
- Peak power output and test conditions are typically only populated for solar PV products

### Changelog

#### 1.0.0

- Initial release
- AJAX API-based scraping (no browser)
- 11 filter options matching the product directory sidebar
- Full product data extraction with SCOP performance data
- 20 output fields with SEO-optimized slugs

### Support

Report issues or request features via [GitHub Issues](https://github.com/anomalyco/opencode/issues).

### Disclaimer

This actor scrapes publicly available data from mcscertified.com. Users are responsible for complying with the website's terms of service and applicable data protection regulations when using scraped data.

# Actor input Schema

## `search` (type: `string`):

Search by product name or certification number.

## `sortBy` (type: `string`):

Sort order for results.

## `manufacturer` (type: `string`):

Filter by manufacturer name (partial match supported).

## `certificationStatus` (type: `array`):

Filter by current certification status. Leave empty for all.

## `technologyTypes` (type: `array`):

Filter by technology categories. Leave empty for all.

## `technologySubTypes` (type: `array`):

Filter by technology sub-type (e.g., Air-to-Air, Air-to-Water). Only applies when Air Source Heat Pump is selected.

## `certifiedFrom` (type: `string`):

Start of certification date range (YYYY-MM-DD).

## `certifiedTo` (type: `string`):

End of certification date range (YYYY-MM-DD).

## `resultsPerPage` (type: `integer`):

Number of products per page.

## `maxPages` (type: `integer`):

Maximum number of pages to scrape. Set to 0 to scrape all pages.

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

Proxy settings for the actor.

## Actor input object example

```json
{
  "resultsPerPage": 30,
  "maxPages": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `productsDataset` (type: `string`):

Complete dataset of scraped MCS-certified products with all fields

# API

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

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<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("morkerr/mcscertified-com-product-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("morkerr/mcscertified-com-product-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 morkerr/mcscertified-com-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MCS Certified Products Scraper",
        "description": "Scrape 260,000+ MCS certified renewable energy products from the official UK scheme directory. Extract certification numbers, manufacturers, model numbers, technology types, SCOP data, and certification details across 12 categories including solar PV, heat pumps, biomass.",
        "version": "1.0",
        "x-build-id": "FgRaSCgqSjpd2Zu4j"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/morkerr~mcscertified-com-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-morkerr-mcscertified-com-product-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/morkerr~mcscertified-com-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-morkerr-mcscertified-com-product-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/morkerr~mcscertified-com-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-morkerr-mcscertified-com-product-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": {
                    "search": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Search by product name or certification number."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "",
                            "date-desc",
                            "date-asc",
                            "title-asc",
                            "title-desc"
                        ],
                        "type": "string",
                        "description": "Sort order for results."
                    },
                    "manufacturer": {
                        "title": "Manufacturer Name",
                        "type": "string",
                        "description": "Filter by manufacturer name (partial match supported)."
                    },
                    "certificationStatus": {
                        "title": "Certification Status",
                        "type": "array",
                        "description": "Filter by current certification status. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "certified",
                                "expired"
                            ],
                            "enumTitles": [
                                "Certified",
                                "Certification Expired"
                            ]
                        }
                    },
                    "technologyTypes": {
                        "title": "Technology Types",
                        "type": "array",
                        "description": "Filter by technology categories. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Air Source Heat Pump",
                                "Biomass",
                                "Exhaust Air Heat Pump",
                                "Gas Absorbtion Heat Pump",
                                "Ground/Water Source Heat Pump",
                                "Micro CHP",
                                "Solar Assisted Heat Pump",
                                "Solar Heating",
                                "Solar Heating Mounting",
                                "Solar PV",
                                "Solar PV Mounting",
                                "Wind Turbine"
                            ],
                            "enumTitles": [
                                "Air Source Heat Pump",
                                "Biomass",
                                "Exhaust Air Heat Pump",
                                "Gas Absorbtion Heat Pump",
                                "Ground/Water Source Heat Pump",
                                "Micro CHP",
                                "Solar Assisted Heat Pump",
                                "Solar Heating",
                                "Solar Heating Mounting",
                                "Solar PV",
                                "Solar PV Mounting",
                                "Wind Turbine"
                            ]
                        }
                    },
                    "technologySubTypes": {
                        "title": "Technology Sub-Types",
                        "type": "array",
                        "description": "Filter by technology sub-type (e.g., Air-to-Air, Air-to-Water). Only applies when Air Source Heat Pump is selected.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Air-to-Air",
                                "Air-to-Water"
                            ],
                            "enumTitles": [
                                "Air to Air Heat Pump",
                                "Air to Water Heat Pump"
                            ]
                        }
                    },
                    "certifiedFrom": {
                        "title": "Certification Date From",
                        "type": "string",
                        "description": "Start of certification date range (YYYY-MM-DD)."
                    },
                    "certifiedTo": {
                        "title": "Certification Date To",
                        "type": "string",
                        "description": "End of certification date range (YYYY-MM-DD)."
                    },
                    "resultsPerPage": {
                        "title": "Results Per Page",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Number of products per page.",
                        "default": 30
                    },
                    "maxPages": {
                        "title": "Max Pages to Scrape",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of pages to scrape. Set to 0 to scrape all pages.",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the actor.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
