# ManoMano Scraper — French DIY & Home Improvement Marketplace (`studio-amba/manomano-scraper`) Actor

Scrape product listings, prices, seller information, ratings, and specifications from ManoMano.fr. Europe's leading online DIY marketplace with 10M+ products from thousands of sellers. No login required.

- **URL**: https://apify.com/studio-amba/manomano-scraper.md
- **Developed by:** [Studio Amba](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 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

## ManoMano Scraper -- French DIY & Home Improvement Marketplace

Scrape product data from ManoMano.fr -- Europe's leading online marketplace for DIY, home improvement, and garden products with over 10 million products from thousands of independent sellers. No login or cookies required.

### How to scrape ManoMano data

ManoMano Scraper extracts product listings from ManoMano.fr including prices, seller information, ratings, specifications, and stock status. Search by keyword or browse categories to get structured, ready-to-use data.

#### What is ManoMano?

ManoMano is Europe's largest online marketplace dedicated to DIY, home improvement, and garden products. Founded in France, it operates in 6 European countries and connects millions of buyers with thousands of professional sellers. Unlike single-retailer stores, ManoMano aggregates offers from multiple merchants, making it a prime source for competitive pricing data.

Who uses this scraper:

- **Price comparison platforms** -- ManoMano aggregates sellers, giving you multi-vendor pricing in one crawl. Compare offers across merchants for the same product.
- **Marketplace sellers & brands** -- Monitor your product listings, track competitor pricing, and detect unauthorized sellers. Know exactly where you stand in search results.
- **E-commerce competitors** -- If you sell DIY, tools, or home improvement products in France, ManoMano pricing sets market expectations. Track what customers see before they visit your store.
- **Market researchers** -- Analyze the French DIY market: seller concentration, price distributions, brand representation, category trends, and promotional patterns.
- **Procurement teams** -- Find the best-priced suppliers for tools, building materials, plumbing, and electrical supplies across thousands of vendors.

#### Search by keyword

The fastest way to find products:

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

#### Browse a category

Scrape an entire product category. Copy category URLs from manomano.fr navigation:

```json
{
    "categoryUrl": "https://www.manomano.fr/cat/perceuses+visseuses-12",
    "maxResults": 200
}
```

#### Scrape specific URLs

Pass individual product pages or listing pages directly:

```json
{
    "startUrls": [
        { "url": "https://www.manomano.fr/cat/peinture-interieure-16" },
        { "url": "https://www.manomano.fr/cat/robinetterie-462" }
    ],
    "maxResults": 500
}
```

**Tip:** Use French residential proxies for best results. ManoMano uses DataDome anti-bot protection that works best with French IP addresses.

### What data does ManoMano Scraper extract?

| Field | Type | Description |
|-------|------|-------------|
| `name` | String | Full product title |
| `brand` | String | Brand or manufacturer name |
| `price` | Number | Current selling price in EUR |
| `currency` | String | Always "EUR" |
| `originalPrice` | Number | Price before discount/promotion |
| `sellerName` | String | Marketplace seller name |
| `sellerRating` | Number | Seller's average rating |
| `inStock` | Boolean | Product availability |
| `rating` | Number | Average product rating (0-5) |
| `reviewCount` | Number | Number of customer reviews |
| `sku` | String | Product SKU or model reference |
| `ean` | String | EAN barcode |
| `imageUrl` | String | Primary product image |
| `description` | String | Product description |
| `category` | String | Product category |
| `categories` | Array | Full breadcrumb path |
| `specs` | Object | Technical specifications (key-value pairs) |

### Output

A realistic ManoMano product record:

```json
{
    "name": "Bosch Professional Perceuse-visseuse sans fil GSR 18V-28",
    "brand": "Bosch Professional",
    "price": 129.90,
    "currency": "EUR",
    "url": "https://www.manomano.fr/p/bosch-professional-perceuse-visseuse-gsr-18v-28-12345678",
    "scrapedAt": "2026-05-19T10:30:00.000Z",
    "originalPrice": 159.90,
    "sellerName": "Outillage Pro FR",
    "sellerRating": 4.7,
    "inStock": true,
    "rating": 4.5,
    "reviewCount": 234,
    "sku": "GSR18V28",
    "ean": "3165140953092",
    "imageUrl": "https://cdn.manomano.com/media/product/bosch-gsr-18v-28.jpg",
    "description": "Perceuse-visseuse sans fil 18V avec mandrin auto-serrant 13mm, couple max 63Nm, eclairage LED integre.",
    "category": "Perceuses-visseuses",
    "categories": ["Outillage", "Outillage electroportatif", "Perceuses-visseuses"],
    "specs": {
        "Tension": "18V",
        "Couple max": "63 Nm",
        "Mandrin": "13 mm",
        "Poids": "1.6 kg"
    }
}
```

### How much does it cost?

| Scenario | Estimated cost |
|----------|---------------|
| 50 products (search) | ~$0.15 |
| 200 products (category) | ~$0.50 |
| 1,000 products (multiple categories) | ~$2.00 |
| Large catalog crawl | ~$5.00+ |

ManoMano Scraper uses PlaywrightCrawler with browser rendering to handle DataDome anti-bot protection. This uses more compute than lightweight scrapers, but ensures reliable data extraction.

### Can I integrate?

Connect ManoMano data to your tools:

- **Google Sheets** -- track French DIY marketplace prices and seller offers
- **Webhooks** -- trigger alerts when prices drop or new sellers appear
- **Zapier / Make** -- automate competitive intelligence workflows
- **Slack** -- daily notifications on price changes in your product categories
- **Amazon S3 / Google Cloud Storage** -- archive pricing snapshots for trend analysis
- **PostgreSQL / MySQL** -- feed marketplace data into your analytics stack

### Can I use it as an API?

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/manomano-scraper").call(run_input={
    "searchQuery": "perceuse",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    seller = f" (by {item['sellerName']})" if item.get('sellerName') else ''
    print(f"{item['brand']} - {item['name']} -- EUR {item['price']}{seller}")
```

#### JavaScript

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

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

const run = await client.actor('studio-amba/manomano-scraper').call({
    searchQuery: 'perceuse',
    maxResults: 50,
    proxyConfiguration: {
        useApifyProxy: true,
        apifyProxyGroups: ['RESIDENTIAL'],
        apifyProxyCountry: 'FR',
    },
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    const seller = item.sellerName ? ` (by ${item.sellerName})` : '';
    console.log(`${item.brand} - ${item.name} -- EUR ${item.price}${seller}`);
});
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | String | | Search for products by keyword (French terms recommended) |
| `categoryUrl` | String | | A ManoMano category page URL |
| `startUrls` | Array | | List of ManoMano URLs to scrape |
| `maxResults` | Integer | `100` | Maximum number of products to return |
| `proxyConfiguration` | Object | Apify proxy | Proxy settings (FR residential recommended) |

### FAQ

**Does this handle ManoMano's anti-bot protection?**
Yes. ManoMano uses DataDome anti-bot. The scraper uses browser fingerprinting and session management to work with it. For best results, use French residential proxies.

**Can I get seller information?**
Yes. The scraper extracts `sellerName` and `sellerRating` for each product. ManoMano is a marketplace with thousands of sellers, so this data is valuable for competitive analysis.

**What language is the data in?**
All data comes in French, matching the manomano.fr site.

**How often do ManoMano prices change?**
ManoMano prices are set by individual sellers and can change at any time. Weekly scraping captures most pricing trends. Daily scraping catches flash sales and promotional events.

**Can I scrape other ManoMano country sites?**
This scraper targets manomano.fr (France). ManoMano also operates in Spain, Italy, Germany, and the UK with separate sites.

### Limitations

- The scraper targets manomano.fr (France). Other ManoMano country sites have different URL structures.
- ManoMano uses DataDome anti-bot protection. French residential proxies are recommended for reliable results.
- Very large crawls (1000+ products) run at low concurrency to avoid detection, so they take longer.
- Seller-specific data (seller rating, seller name) is most complete on product detail pages. Listing-page results may have partial seller info.
- Product specifications vary by category. Some products have detailed specs, others have minimal info.

### Other DIY and home improvement scrapers

Build comprehensive European DIY market intelligence:

- [Leroy Merlin Scraper](https://apify.com/studio-amba/leroymerlin-scraper) -- France's largest DIY retailer
- [Castorama Scraper](https://apify.com/studio-amba/castorama-scraper) -- French DIY chain (Kingfisher group)
- [Hornbach Scraper](https://apify.com/studio-amba/hornbach-scraper) -- German DIY retailer across Europe
- [Bauhaus Scraper](https://apify.com/studio-amba/bauhaus-scraper) -- European building materials
- [OBI Scraper](https://apify.com/studio-amba/obi-scraper) -- German home improvement chain
- [Brico Depot Scraper](https://apify.com/studio-amba/bricodepot-scraper) -- Budget DIY in France
- [Gamma Scraper](https://apify.com/studio-amba/gamma-scraper) -- Dutch DIY retailer
- [HUBO Scraper](https://apify.com/studio-amba/hubo-scraper) -- Belgian DIY chain

### Your feedback

Found an issue or want a new feature? Let us know through the Apify Store actor page. We fix bugs quickly and actively maintain this scraper.

# Actor input Schema

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

Search for products by name or keyword (e.g., 'perceuse', 'peinture', 'robinet'). Leave empty to use Start URLs or Category URL instead.

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

A ManoMano category page URL. Example: https://www.manomano.fr/cat/perceuses+visseuses-12

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

List of ManoMano URLs to scrape (category pages, search results, or individual product pages).

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

Maximum number of products to return.

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

Proxy settings. ManoMano uses DataDome anti-bot — French RESIDENTIAL proxies are required for reliable results.

## Actor input object example

```json
{
  "searchQuery": "perceuse",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# 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 = {
    "searchQuery": "perceuse",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/manomano-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 = {
    "searchQuery": "perceuse",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/manomano-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 '{
  "searchQuery": "perceuse",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call studio-amba/manomano-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ManoMano Scraper — French DIY & Home Improvement Marketplace",
        "description": "Scrape product listings, prices, seller information, ratings, and specifications from ManoMano.fr. Europe's leading online DIY marketplace with 10M+ products from thousands of sellers. No login required.",
        "version": "0.1",
        "x-build-id": "zQ21GjD1ODlJe4uYJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~manomano-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-manomano-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~manomano-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-manomano-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~manomano-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-manomano-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by name or keyword (e.g., 'perceuse', 'peinture', 'robinet'). Leave empty to use Start URLs or Category URL instead."
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "A ManoMano category page URL. Example: https://www.manomano.fr/cat/perceuses+visseuses-12"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of ManoMano URLs to scrape (category pages, search results, or individual product pages).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. ManoMano uses DataDome anti-bot — French RESIDENTIAL proxies are required for reliable results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "FR"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
