# Dacia & Renault Configurator Scraper (`rastriq/dacia-renault-configurator`) Actor
Extract models, versions, prices, colors, and specs from Dacia and Renault configurators across 23 European markets. No API key needed. Export to JSON, CSV, or Excel.
- **URL**: https://apify.com/rastriq/dacia-renault-configurator.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $5.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
## Dacia & Renault Configurator Scraper
Extract **models, versions, prices, colors, and specifications** from Dacia and Renault configurators across 23 European markets — no API key or login required. The Dacia & Renault Configurator Scraper delivers structured catalog data in JSON, CSV, or Excel, ready for market intelligence, competitive analysis, or pricing dashboards.
> Try it free — your first $5 of usage is on Apify. No credit card required.
### What is Dacia & Renault Configurator Scraper?
**Dacia & Renault Configurator Scraper** is an unofficial Renault Group catalog API that extracts the complete vehicle lineup directly from the official configurator. Unlike manually browsing each country's website, this scraper pulls **every model, version, and trim level** across all markets in a single run.
Use Dacia & Renault Configurator Scraper to:
- **Monitor pricing across markets** — compare retail prices for the same model across Spain, France, Germany, Italy, and 19 more countries
- **Track the full catalog** — get every version, grade, engine variant, and color option available
- **Analyze market differences** — discover which models and trims are offered in which countries
- **Automate recurring workflows** — schedule daily or weekly runs to track catalog changes, new model launches, and price updates
The Apify platform gives Dacia & Renault Configurator Scraper superpowers: **scheduling**, **monitoring**, **API access**, **proxy rotation**, and **integrations** with Make, Zapier, Google Sheets, and more — all out of the box.
### What data does Dacia & Renault Configurator Scraper extract?
Dacia & Renault Configurator Scraper returns structured data with the following fields:
| | |
| ------------------------ | ---------------------------------- |
| Brand & model | Version name & grade |
| Retail price & currency | Price type (PVP, PVC, PVPPTE...) |
| Pre-tax price | Available colors & color codes |
| Country / market | Model phase & program code |
| Vehicle type (VP/VU) | Configurator URL |
Each item represents one specific **version** (engine + trim combination) with its country-specific pricing. Fields like colors and pre-tax price may not be available for all markets.
### How to use Dacia & Renault Configurator Scraper
Extracting Renault Group catalog data takes under two minutes:
1. **Create a free Apify account** at [apify.com](https://apify.com) — your first $5 is free
2. **Open Dacia & Renault Configurator Scraper** in Apify Console or click **Try for free** on this page
3. **Select your brands** — choose Dacia, Renault, or both
4. **Pick your countries** — select from 23 European markets with flag indicators
5. **Choose models** (optional) — select specific model families or leave empty for all
6. **Click Start** and wait for results (typically 1–3 minutes for a few countries)
6. **Download your data** in JSON, CSV, Excel, or XML — or access via API
### Input parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `brands` | array | No | `["dacia"]` | Brands to scrape: Dacia, Renault, or both |
| `countries` | array | No | 13 main markets | European markets to cover (23 available) |
| `models` | array | No | `[]` (all) | Select specific model families (e.g. SANDERO, CLIO). Empty = all |
| `proxyConfiguration` | object | No | — | Optional proxy settings for rate-limited environments |
**Example input for a quick test:**
```json
{
"brands": ["dacia", "renault"],
"countries": ["ES", "FR", "DE"],
"models": ["SANDERO", "CLIO"]
}
````
### Output example
Each result is a structured JSON object. Here is a sample from a real run:
```json
{
"brand": "dacia",
"country": "ES",
"model": "JOGGER",
"model_spec_code": "RI1",
"version_id": "VEC243_ESPA",
"version_name": "Extreme Go hybrid 140 7 plazas",
"grade": "Extreme Go",
"price_retail": 27600,
"price_type": "PVP",
"price_without_tax": 22499.92,
"currency": "EUR",
"colors": ["gris pizarra", "Verde Cedro", "Naranja Terracota", "Liquen Caqui", "Gris Urban", "blanco glaciar", "Negro Nacarado"],
"color_codes": ["TEKQG", "TEDQK", "TECNZ", "OVKQM", "OVKPW", "OV369", "NV676"],
"phase": "1",
"program": "XJF",
"commercial_kind": "VP",
"configurator_url": "https://es.co.rplug.renault.com/c/BAHCv/A",
"scraped_at": "2026-07-04T06:44:36.381162+00:00"
}
```
Download results in **JSON, CSV, Excel, XML, or HTML** from the Output tab, or pull them programmatically using the Apify API (see the API tab for ready-to-use code snippets).
### Supported countries
Dacia & Renault Configurator Scraper covers **23 European markets**, each returning prices in the local price type and currency:
| Market | Price type | Currency |
|--------|-----------|----------|
| Spain | PVP | EUR |
| France, Germany, Netherlands, Belgium, Austria, Luxembourg, Finland, Ireland, Slovenia, Slovakia, Croatia | PVC | EUR |
| Italy | PVCCEM | EUR |
| Portugal | PVPPTE | EUR |
| Poland | PVC | PLN |
| Romania | PVC | RON |
| Czech Republic | PVC | CZK |
| Hungary | PVC | HUF |
| Bulgaria | PVC | BGN |
| Switzerland | PVC | CHF |
| Denmark | PVC | DKK |
| Sweden | PVC | SEK |
| Norway | PVC | NOK |
### Setting up recurring monitoring
Dacia & Renault Configurator Scraper is designed for both one-time extractions and continuous monitoring:
1. **Save your input as a Task** in Apify Console after configuring brands and countries
2. **Go to Schedules** and set the frequency: daily, weekly, or custom cron
3. **Add a webhook** to receive data in Slack, email, or your own endpoint when each run finishes
4. **Compare datasets** across runs to detect price changes, new models, or discontinued versions
### Frequently Asked Questions
#### Is scraping Dacia and Renault configurators legal?
Dacia & Renault Configurator Scraper only accesses **publicly available data** from the official Renault Group configurator — the same information visible to any visitor browsing the website. We respect rate limiting and apply reasonable delays between requests.
As with any data collection activity, you are responsible for ensuring your use case complies with applicable laws (GDPR, CCPA) and the website's Terms of Service. For guidance, see [Apify's blog on the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).
#### Does Dacia & Renault Configurator Scraper require a login or API key?
No. The scraper works entirely with **public configurator data** and does not require any account, login, or API credentials.
#### How many results can I get?
A full run across all 23 countries with both brands typically returns **2,000–4,000 items** (versions), depending on the current catalog. Each item represents a unique version (model + engine + trim) in a specific country.
#### What proxy configuration should I use?
The configurator API works **without proxies** from most locations. Datacenter proxies are sufficient if you experience rate limiting. Residential proxies are not required.
#### How do I integrate Dacia & Renault Configurator Scraper with my workflow?
The scraper integrates natively with:
- **Make (formerly Integromat)** and **Zapier** — trigger runs and receive data automatically
- **Google Sheets** — export directly to a spreadsheet
- **Webhooks** — get notified when a run finishes
- **Apify API** — call from Python, Node.js, or any language (see the API tab)
#### I found a bug or my run failed. Where do I report it?
Please open an issue in the **Issues tab** on this page. Include your input configuration and the run ID so we can investigate quickly.
***
### Version en espanol
> Esta seccion es un resumen en espanol del README anterior.
#### Que es Dacia & Renault Configurator Scraper?
**Dacia & Renault Configurator Scraper** extrae el catalogo completo de modelos, versiones, precios, colores y especificaciones del configurador oficial de Dacia y Renault en 23 mercados europeos. No requiere API key ni login.
#### Que datos extrae?
Cada resultado incluye: marca, pais, modelo, version, nivel de acabado (grade), precio de venta al publico, precio sin impuestos, colores disponibles, tipo de vehiculo, y enlace al configurador. Los precios se devuelven en el tipo de precio local de cada pais (PVP en Espana, PVC en Francia/Alemania, PVPPTE en Portugal, etc.).
#### Como usar Dacia & Renault Configurator Scraper?
1. Crea una cuenta gratuita en [apify.com](https://apify.com)
2. Abre el actor y selecciona las marcas (Dacia, Renault o ambas)
3. Elige los paises que quieres cubrir
4. Haz clic en **Start** y espera los resultados
5. Descarga los datos en JSON, CSV o Excel
#### Cuantos resultados puedo obte
# Actor input Schema
## `brands` (type: `array`):
Select one or both brands to scrape.
• Dacia — budget-friendly models (Sandero, Duster, Jogger, Spring, Bigster)
• Renault — full range (Clio, Captur, Megane, Arkana, Austral, Espace, Master, Kangoo)
💡 Tip: Select both brands to get the complete Renault Group catalog.
## `countries` (type: `array`):
Select the European markets to scrape. Each country returns local pricing in the correct price type (PVP, PVC, PVPPTE, etc.) and local currency.
💡 Tip: Start with 1–2 countries for a quick test run.
## `models` (type: `array`):
Select specific model families to scrape, or leave empty for all models.
Models are grouped by brand. The scraper matches by family name across all countries, regardless of localized prefixes (e.g. selecting JOGGER matches "NUEVO JOGGER" in Spain, "NOUVEAU JOGGER" in France, etc.).
💡 Tip: Select 1–2 models for a quick test run before scaling.
## `proxyConfiguration` (type: `object`):
Optional. The configurator API works without proxies from most locations. Only enable if you experience rate limiting or blocks.
## Actor input object example
```json
{
"brands": [
"dacia"
],
"countries": [
"ES",
"FR",
"DE",
"IT",
"PT",
"BE",
"NL",
"AT",
"PL",
"RO",
"HR",
"CZ",
"HU"
],
"models": [
"SANDERO",
"CLIO"
]
}
```
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"models": [
"SANDERO",
"CLIO"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/dacia-renault-configurator").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = { "models": [
"SANDERO",
"CLIO",
] }
# Run the Actor and wait for it to finish
run = client.actor("rastriq/dacia-renault-configurator").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 '{
"models": [
"SANDERO",
"CLIO"
]
}' |
apify call rastriq/dacia-renault-configurator --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=rastriq/dacia-renault-configurator",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Dacia & Renault Configurator Scraper",
"description": "Extract models, versions, prices, colors, and specs from Dacia and Renault configurators across 23 European markets. No API key needed. Export to JSON, CSV, or Excel.",
"version": "0.1",
"x-build-id": "79c9J45gJ3GOYMlKv"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/rastriq~dacia-renault-configurator/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-rastriq-dacia-renault-configurator",
"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/rastriq~dacia-renault-configurator/runs": {
"post": {
"operationId": "runs-sync-rastriq-dacia-renault-configurator",
"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/rastriq~dacia-renault-configurator/run-sync": {
"post": {
"operationId": "run-sync-rastriq-dacia-renault-configurator",
"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": {
"brands": {
"title": "🚗 Brands",
"uniqueItems": true,
"type": "array",
"description": "Select one or both brands to scrape.
• Dacia — budget-friendly models (Sandero, Duster, Jogger, Spring, Bigster)
• Renault — full range (Clio, Captur, Megane, Arkana, Austral, Espace, Master, Kangoo)
💡 Tip: Select both brands to get the complete Renault Group catalog.",
"items": {
"type": "string",
"enum": [
"dacia",
"renault"
],
"enumTitles": [
"Dacia",
"Renault"
]
},
"default": [
"dacia"
]
},
"countries": {
"title": "🌍 Countries",
"uniqueItems": true,
"type": "array",
"description": "Select the European markets to scrape. Each country returns local pricing in the correct price type (PVP, PVC, PVPPTE, etc.) and local currency.
💡 Tip: Start with 1–2 countries for a quick test run.",
"items": {
"type": "string",
"enum": [
"ES",
"FR",
"DE",
"IT",
"PT",
"BE",
"NL",
"AT",
"PL",
"RO",
"HR",
"CZ",
"HU",
"BG",
"SI",
"SK",
"LU",
"CH",
"DK",
"SE",
"NO",
"FI",
"IE"
],
"enumTitles": [
"🇪🇸 Spain (EUR)",
"🇫🇷 France (EUR)",
"🇩🇪 Germany (EUR)",
"🇮🇹 Italy (EUR)",
"🇵🇹 Portugal (EUR)",
"🇧🇪 Belgium (EUR)",
"🇳🇱 Netherlands (EUR)",
"🇦🇹 Austria (EUR)",
"🇵🇱 Poland (PLN)",
"🇷🇴 Romania (RON)",
"🇭🇷 Croatia (EUR)",
"🇨🇿 Czech Republic (CZK)",
"🇭🇺 Hungary (HUF)",
"🇧🇬 Bulgaria (BGN)",
"🇸🇮 Slovenia (EUR)",
"🇸🇰 Slovakia (EUR)",
"🇱🇺 Luxembourg (EUR)",
"🇨🇭 Switzerland (CHF)",
"🇩🇰 Denmark (DKK)",
"🇸🇪 Sweden (SEK)",
"🇳🇴 Norway (NOK)",
"🇫🇮 Finland (EUR)",
"🇮🇪 Ireland (EUR)"
]
},
"default": [
"ES",
"FR",
"DE",
"IT",
"PT",
"BE",
"NL",
"AT",
"PL",
"RO",
"HR",
"CZ",
"HU"
]
},
"models": {
"title": "🚘 Models",
"uniqueItems": true,
"type": "array",
"description": "Select specific model families to scrape, or leave empty for all models.
Models are grouped by brand. The scraper matches by family name across all countries, regardless of localized prefixes (e.g. selecting JOGGER matches \"NUEVO JOGGER\" in Spain, \"NOUVEAU JOGGER\" in France, etc.).
💡 Tip: Select 1–2 models for a quick test run before scaling.",
"items": {
"type": "string",
"enum": [
"SANDERO",
"DUSTER",
"JOGGER",
"SPRING",
"BIGSTER",
"CLIO",
"CAPTUR",
"ARKANA",
"MEGANE",
"SYMBIOZ",
"SCENIC",
"RAFALE",
"AUSTRAL",
"ESPACE",
"RENAULT 5",
"RENAULT 4",
"TWINGO",
"KANGOO",
"TRAFIC",
"MASTER",
"EXPRESS"
],
"enumTitles": [
"Dacia — SANDERO",
"Dacia — DUSTER",
"Dacia — JOGGER",
"Dacia — SPRING",
"Dacia — BIGSTER",
"Renault — CLIO",
"Renault — CAPTUR",
"Renault — ARKANA",
"Renault — MEGANE E-TECH",
"Renault — SYMBIOZ",
"Renault — SCENIC E-TECH",
"Renault — RAFALE",
"Renault — AUSTRAL",
"Renault — ESPACE",
"Renault — RENAULT 5",
"Renault — RENAULT 4",
"Renault — TWINGO",
"Renault VU — KANGOO",
"Renault VU — TRAFIC",
"Renault VU — MASTER",
"Renault VU — EXPRESS"
]
},
"default": []
},
"proxyConfiguration": {
"title": "🔒 Proxy configuration",
"type": "object",
"description": "Optional. The configurator API works without proxies from most locations. Only enable if you experience rate limiting or blocks."
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```