# Brico Scraper — Belgian DIY Products & Home Improvement Prices (`studio-amba/brico-scraper`) Actor

Scrape products from Brico.be, Belgium's largest DIY chain (Colruyt Group). Tools, building materials, garden furniture, paint, plumbing, and electrical supplies.

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

## Pricing

from $5.00 / 1,000 result scrapeds

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

## Brico Scraper -- Belgium's Largest DIY Chain

Scrape products, prices, availability, ratings, and promotions from brico.be -- Belgium's biggest DIY and home improvement retailer, part of the Colruyt Group. Covers 140+ stores and a deep online catalog of tools, building materials, garden, paint, plumbing, and electrical supplies. Bilingual support for Dutch and French.

### What is Brico Scraper?

Brico is Belgium's market leader in DIY retail, operating over 140 stores across all Belgian provinces under the Colruyt Group umbrella. Its online catalog is one of the most comprehensive in the Belgian home improvement space, carrying everything from Makita power tools and Levis paint to garden furniture and bathroom fixtures. The Brico brand also includes Brico Plan-It for larger-format stores.

This actor supports two extraction modes: a fast search API for keyword queries, and HTML crawling for category page browsing. Both modes deliver structured product data with pricing, availability, ratings, and category information.

- **Belgian DIY market price intelligence** -- Monitor Brico's pricing and promotions against GAMMA, Hubo, and other local competitors to understand the Belgian home improvement pricing landscape
- **Promotional cycle analysis** -- Track how Brico runs promotions (discount percentages, labels like "2e aan halve prijs") to time your purchasing or benchmark your own retail pricing
- **Product assortment mapping** -- Catalog Brico's full offering by category to identify gaps, overlaps, or opportunities versus competitors
- **Colruyt Group retail research** -- Brico is part of Belgium's largest retail group; studying its DIY catalog gives insight into Colruyt's category management strategy
- **Supplier brand tracking** -- Monitor how brands like Bosch, DeWalt, Gardena, or Weber are positioned and priced at Belgium's largest DIY retailer

### What data does Brico Scraper extract?

- 🔨 **Product name** -- Full product title in Dutch or French
- 💰 **Price & promotions** -- Current price, original price, discount label, and discount percentage
- 🏷️ **Brand** -- Manufacturer name (Bosch, Makita, Gardena, Levis, etc.)
- 📦 **Stock & delivery** -- Availability status and delivery mode information
- ⭐ **Ratings & reviews** -- Customer star rating and review count
- 🖼️ **Product image** -- Product thumbnail URL (424x424)
- 🔗 **Product URL** -- Direct link to the product on brico.be
- 📂 **Category hierarchy** -- Full category path from parent categories
- 🏗️ **Product identifiers** -- EAN barcode, product ID/SKU
- 🌐 **Language** -- Output language (nl or fr)

### How to scrape Brico

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | String | Search by keyword -- e.g., `"boormachine"`, `"tuinslang"`, `"verf"` |
| `startUrls` | Array | Brico.be category or product page URLs to scrape |
| `maxResults` | Integer | Maximum products to return (default: 100, max: 10,000) |
| `language` | String | `"nl"` (Dutch, default) or `"fr"` (French) |
| `proxyConfiguration` | Object | Optional proxy for large runs |

**Tips:**
- `searchQuery` is the fastest mode -- it uses Brico's internal search API directly, no page crawling needed
- For category browsing, paste a Brico category URL into `startUrls` (e.g., `https://www.brico.be/nl/tuin-terras-buitenleven/tuinmeubelen/tuinstoelen/ga151/`)
- The search API returns 24 products per page and handles pagination automatically
- Both Dutch and French return the same products with localized names

### Output

```json
{
    "name": "Makita accu schroefboormachine DDF487Z 18V",
    "brand": "Makita",
    "price": 129.00,
    "currency": "EUR",
    "url": "https://www.brico.be/nl/gereedschap/elektrisch-gereedschap/boormachines/makita-accu-schroefboormachine-ddf487z/5678901",
    "scrapedAt": "2026-04-03T11:00:00.000Z",
    "originalPrice": 149.00,
    "discount": "-13%",
    "ean": "0088381736480",
    "sku": "5678901",
    "productId": "5678901",
    "inStock": true,
    "deliveryInfo": "AVAILABLE",
    "rating": 4.8,
    "reviewCount": 56,
    "imageUrl": "https://www.brico.be/media/5678901/424x424/origin.jpg",
    "category": "Gereedschap > Elektrisch gereedschap > Boormachines",
    "categories": ["Gereedschap", "Elektrisch gereedschap", "Boormachines"],
    "language": "nl"
}
````

A garden product example:

```json
{
    "name": "Gardena Classic tuinslang 1/2\" 20m",
    "brand": "Gardena",
    "price": 24.99,
    "currency": "EUR",
    "url": "https://www.brico.be/nl/tuin-terras-buitenleven/bewatering/tuinslangen/gardena-classic-tuinslang/4567890",
    "scrapedAt": "2026-04-03T11:00:00.000Z",
    "ean": "4078500001762",
    "sku": "4567890",
    "productId": "4567890",
    "inStock": true,
    "rating": 4.3,
    "reviewCount": 31,
    "imageUrl": "https://www.brico.be/media/4567890/424x424/origin.jpg",
    "category": "Tuin & Terras > Bewatering > Tuinslangen",
    "categories": ["Tuin & Terras", "Bewatering", "Tuinslangen"],
    "language": "nl"
}
```

### How much does it cost?

Brico Scraper uses direct API calls in search mode, keeping costs low.

| Scenario | Products | Est. cost |
|----------|----------|-----------|
| Quick search | 100 | ~$0.10 |
| Category export | 500 | ~$0.30 |
| Full department scan | 2,000 | ~$0.80 |
| Weekly monitoring run | 1,000/week | ~$1.50/month |

Category crawling mode (using `startUrls`) is slightly more expensive due to HTML parsing overhead.

### Can I integrate?

Export data in any format Apify supports:

- **JSON, CSV, Excel** -- Direct download from dataset
- **Google Sheets** -- Automatic sync
- **Webhooks** -- Trigger your pipeline on completion
- **API** -- Programmatic access (see below)
- **Zapier / Make** -- Connect to 5,000+ apps
- **Amazon S3, Google Cloud Storage** -- Cloud storage export

### Can I use it as an API?

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/brico-scraper").call(run_input={
    "searchQuery": "tuinmeubelen",
    "maxResults": 200,
    "language": "nl"
})

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/brico-scraper').call({
    searchQuery: 'tuinmeubelen',
    maxResults: 200,
    language: 'nl',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### FAQ

**What is the difference between Brico and Brico Plan-It?**
Brico Plan-It is the larger-format variant of Brico stores with a wider assortment. Both share the same online catalog at brico.be, so this scraper covers products from both store formats.

**Can I get store-level stock information?**
The scraper returns the general availability status from the Brico API (`AVAILABLE`, `OUT_OF_STOCK`, etc.). Individual store-level inventory is not exposed through the public search API.

**How does Brico compare to GAMMA and Hubo?**
Brico is the largest Belgian DIY chain by store count (140+). GAMMA (80+ stores) is part of the Intergamma group and tends to be strong in the Flemish market. Hubo operates smaller neighborhood stores. All three target the Belgian consumer DIY market but differ in assortment depth and store format.

**Does Brico have its own private-label brands?**
Yes. Brico carries several private-label lines. You can spot them by filtering for products where the brand field matches Brico-specific names. Most branded products come from major manufacturers like Bosch, Makita, Gardena, and Levis.

**Can I scrape in both Dutch and French simultaneously?**
Not in a single run. Set `language` to `"nl"` or `"fr"` and run separately. Both languages return the same products with localized titles and category names.

### Limitations

- Search API returns 24 products per page -- large catalogs require many API calls
- Category page crawling requires properly formatted Brico.be URLs with the category code (e.g., `/ga151/`)
- Product descriptions and detailed specs are not included in the search API response; they would require visiting individual product pages
- Stock status is general (online availability), not store-specific
- Proxy is recommended for runs above 1,000 products to avoid rate limiting

### Other DIY & home improvement scrapers

Compare Belgian and European DIY pricing with these companion scrapers:

- **[GAMMA Scraper](https://apify.com/studio-amba/gamma-scraper)** -- Belgium, Intergamma group (80+ stores)
- **[Hubo Scraper](https://apify.com/studio-amba/hubo-scraper)** -- Belgian neighborhood DIY stores
- **[Praxis Scraper](https://apify.com/studio-amba/praxis-scraper)** -- Netherlands, Maxeda DIY Group
- **[Leroy Merlin Scraper](https://apify.com/studio-amba/leroymerlin-scraper)** -- France's #1 DIY retailer
- **[Castorama Scraper](https://apify.com/studio-amba/castorama-scraper)** -- France, Kingfisher group
- **[OBI Scraper](https://apify.com/studio-amba/obi-scraper)** -- Germany's leading DIY chain
- **[Hornbach Scraper](https://apify.com/studio-amba/hornbach-scraper)** -- German/EU DIY megastore
- **[Bauhaus Scraper](https://apify.com/studio-amba/bauhaus-scraper)** -- German/EU hardware & DIY
- **[Toom Scraper](https://apify.com/studio-amba/toom-scraper)** -- Germany, REWE group DIY

### Your feedback

Have a question? Found a bug? Need additional data fields? Open an issue on the actor's page or reach out through Apify. We actively maintain this scraper based on user feedback.

# Actor input Schema

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

Brico.be category or product pages to scrape. Example: https://www.brico.be/nl/tuin-terras-buitenleven/tuinmeubelen/tuinstoelen/ga151/

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

Search for products by name or keyword (e.g., 'boormachine', 'tuinslang'). Overrides category URLs.

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

Maximum number of products to return.

## `language` (type: `string`):

Language for product data. Dutch (nl) or French (fr).

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

Proxy settings. Recommended for large runs to avoid rate limiting.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.brico.be/nl/tuin-terras-buitenleven/tuinmeubelen/tuinstoelen/ga151/"
    }
  ],
  "maxResults": 100,
  "language": "nl"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.brico.be/nl/tuin-terras-buitenleven/tuinmeubelen/tuinstoelen/ga151/"
        }
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "startUrls": [{ "url": "https://www.brico.be/nl/tuin-terras-buitenleven/tuinmeubelen/tuinstoelen/ga151/" }] }

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/brico-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.brico.be/nl/tuin-terras-buitenleven/tuinmeubelen/tuinstoelen/ga151/"
    }
  ]
}' |
apify call studio-amba/brico-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Brico Scraper — Belgian DIY Products & Home Improvement Prices",
        "description": "Scrape products from Brico.be, Belgium's largest DIY chain (Colruyt Group). Tools, building materials, garden furniture, paint, plumbing, and electrical supplies.",
        "version": "0.1",
        "x-build-id": "fCe2s1arlDjucpHE9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~brico-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-brico-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~brico-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-brico-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~brico-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-brico-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": {
                    "startUrls": {
                        "title": "Category or Product URLs",
                        "type": "array",
                        "description": "Brico.be category or product pages to scrape. Example: https://www.brico.be/nl/tuin-terras-buitenleven/tuinmeubelen/tuinstoelen/ga151/",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by name or keyword (e.g., 'boormachine', 'tuinslang'). Overrides category URLs."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "nl",
                            "fr"
                        ],
                        "type": "string",
                        "description": "Language for product data. Dutch (nl) or French (fr).",
                        "default": "nl"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Recommended for large runs to avoid rate limiting."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
