# Cadremploi Scraper - French Executive Cadre Job Offers (`studio-amba/cadremploi-scraper`) Actor

Scrape executive (cadre) job offers from Cadremploi (cadremploi.fr), a major French job board for managers and professionals. Search by keyword and contract type. Extract titles, companies, locations, salaries, contract types, full descriptions and required profiles. No login or cookies required.

- **URL**: https://apify.com/studio-amba/cadremploi-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Cadremploi Scraper — French Executive Cadre Job Offers

Scrape executive (cadre) job offers from [Cadremploi](https://www.cadremploi.fr) (cadremploi.fr), one of France's leading job boards for managers and professionals. Search by keyword and contract type, then export clean structured data with companies, locations, salaries, contract types, and full descriptions. No login, no cookies.

### Why use this actor?

Cadremploi is a major French job board dedicated to cadre (executive/professional) roles, spanning finance, engineering, sales, IT, HR, and management across every industry. If you build a jobs aggregator, run salary benchmarks for management roles, track hiring demand by sector, or feed a recruitment CRM, this actor turns the Cadremploi search into a structured feed you can query on a schedule.

Each result carries its title, hiring company (or recruitment cabinet), location, contract type, salary band (when published), and publication date straight from the search results. Turn on full descriptions and each row also gets the complete job text, the required-profile text, exact salary figures, postal code, region, and industry pulled from the offer's own structured job data.

### How to scrape Cadremploi data

1. Open the actor and set a **Search Query** in French — for example `comptable`, `directeur financier`, `chef de projet`, or `responsable commercial`.
2. Optionally set a **Location** (city or region such as `Paris`, `Lyon`, or `Rhone`) and a **Contract Type** (CDI, CDD, Interim, Freelance, Alternance, Stage).
3. Set **Max Results** to the number of offers you want.
4. Leave **Fetch Full Descriptions** on for the complete job text, required profile, and exact salary range, or turn it off for faster listing-only results.
5. Provide a **Bright Data API Key** (or set the `BRIGHT_DATA_API_KEY` environment variable on the actor) — Cadremploi sits behind a hard Cloudflare block that only the Bright Data Web Unlocker clears, even through a residential proxy.
6. Click **Start**. When the run finishes, export the dataset as JSON, CSV, or Excel, or pull it from the Apify API.

The actor paginates through the Cadremploi search results automatically (50 offers per page) until it reaches your Max Results or runs out of matching offers.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Job search keyword in French (e.g. `comptable`, `directeur financier`). Defaults to `comptable` if empty. |
| `location` | String | No | City or region (e.g. `Paris`, `Lyon`, `Rhone`). Leave empty for all of France. |
| `contractType` | String | No | `all`, `CDI`, `CDD`, `INTERIM`, `FREELANCE`, `ALTERNANCE`, or `STAGE`. |
| `maxResults` | Integer | No | Maximum number of offers to scrape (default: 100). |
| `fetchDetails` | Boolean | No | Fetch each offer's detail page for the full description, required profile, exact salary, postal code and region (default: true). |
| `brightDataApiKey` | String | Yes* | Bright Data Web Unlocker API key. *Required unless `BRIGHT_DATA_API_KEY` is set as an actor environment variable. |
| `proxyConfiguration` | Object | No | Proxy settings for auxiliary requests. The actual page fetches always go through Bright Data. |

### Output

Each result contains:

| Field | Type | Example |
|-------|------|---------|
| `jobTitle` | String | `"Comptable H/F"` |
| `company` | String | `"LEA Recrutement"` |
| `companyType` | String | `"CABINET"` or `"ENTREPRISE"` |
| `location` | String | `"Montpellier"` |
| `postalCode` | String | `"34070"` |
| `region` | String | `"Languedoc-Roussillon"` |
| `contractType` | String | `"CDI"` |
| `employmentType` | String | `"FULL_TIME"` |
| `salary` | String | `"35K€ - 40K€"` |
| `salaryMin` | Number | `35000` |
| `salaryMax` | Number | `40000` |
| `salaryCurrency` | String | `"EUR"` |
| `salaryPeriod` | String | `"annual"` |
| `jobDescription` | String | Full job description text |
| `qualifications` | String | Required profile / qualifications text |
| `industry` | String | `"Cabinet Comptable - Audit"` |
| `companyDescription` | String | Short company description (when published) |
| `companyLogo` | String | Company logo image URL |
| `publishedDate` | String | `"2026-07-13T23:21:01.769Z"` |
| `publishedText` | String | `"Publiée il y a 4 jours"` |
| `offerId` | String | `"156543938973959999"` |
| `url` | String | Full URL to the offer on cadremploi.fr |
| `scrapedAt` | String | ISO timestamp of when the row was scraped |

### Example output

```json
{
    "jobTitle": "Comptable H/F",
    "company": "LEA Recrutement",
    "companyType": "CABINET",
    "location": "Montpellier",
    "postalCode": "34070",
    "region": "Languedoc-Roussillon",
    "contractType": "CDI",
    "employmentType": "FULL_TIME",
    "salary": "35K€ - 40K€",
    "salaryMin": 35000,
    "salaryMax": 40000,
    "salaryCurrency": "EUR",
    "salaryPeriod": "annual",
    "jobDescription": "LEA Recrutement vous présente une nouvelle opportunité professionnelle...",
    "qualifications": "Vous avez une expérience significative en cabinet comptable...",
    "industry": "Cabinet Comptable - Audit",
    "companyDescription": "Le pôle audit, expertise comptable et juridique de LEA...",
    "companyLogo": "https://lh3.googleusercontent.com/...",
    "publishedDate": "2026-07-13T23:21:01.769Z",
    "publishedText": "Publiée il y a 4 jours",
    "offerId": "156543938973959999",
    "url": "https://www.cadremploi.fr/emploi/detail_offre?offreId=156543938973959999",
    "scrapedAt": "2026-07-14T21:00:00.000Z"
}
````

### Salary parsing

Cadremploi publishes salaries on search cards as short text (for example `"35K€ - 40K€"`). The actor keeps the original text in `salary` and parses it into `salaryMin`/`salaryMax`. With **Fetch Full Descriptions** on, the exact figures and period (`annual`, `monthly`, `hourly`) come straight from the offer's structured `baseSalary` data when the recruiter published one. Not every offer publishes a salary — those rows leave the salary fields empty, which is expected.

### Cost estimate

Cadremploi is behind a Cloudflare managed challenge, so every page fetch (search pages and, with **Fetch Full Descriptions** on, each offer's detail page) goes through the Bright Data Web Unlocker. A typical run of a few hundred offers costs a modest amount of Bright Data usage plus the Apify pay-per-result fee. Turn off `fetchDetails` to roughly halve the Bright Data requests when you only need titles, companies, locations, salaries, contract types, and links — everything already on the listing card.

### Limitations / known issues

- **Requires a Bright Data API key.** Cadremploi returns a hard Cloudflare block ("Attention Required") to direct requests and even to browser automation through a residential proxy — only the Bright Data Web Unlocker reliably clears it.
- **Executive-only roles.** Cadremploi focuses on cadre (management/professional) positions. For general job listings, pair it with a HelloWork scraper; for another executive board, pair it with an APEC scraper.
- **Salary is not always published.** Many French offers omit salary. When present, both the raw text and parsed min/max are returned; when absent, the salary fields are empty.
- **Location and contract filters are applied after fetching.** The actor paginates the keyword search and filters cards client-side by location text and contract type, so a narrow filter on a broad keyword may need to walk a few extra pages.

### Related scrapers

- [APEC Scraper](https://apify.com/studio-amba/apec-scraper) — France's other major executive (cadre) job board.
- [HelloWork Scraper](https://apify.com/studio-amba/hellowork-scraper) — France's largest general job board, all sectors.
- [Jobat Scraper](https://apify.com/studio-amba/jobat-scraper) — Belgian job board.
- [Pracuj Scraper](https://apify.com/studio-amba/pracuj-scraper) — Poland's largest job board.
- [InfoJobs Scraper](https://apify.com/studio-amba/infojobs-scraper) — Spain's largest job board.

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API — maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

### Disclaimer

This actor collects only publicly available job-offer data from cadremploi.fr for legitimate use such as market research and job aggregation. Respect Cadremploi's terms of service and applicable data-protection law when using the output.

# Actor input Schema

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

Job search keyword in French (e.g. 'comptable', 'directeur financier', 'chef de projet', 'developpeur'). Leave empty to browse the most recent cadre offers.

## `location` (type: `string`):

Filter by city or region name (e.g. 'Paris', 'Lyon', 'Rhone'). Matches the offer location text. Leave empty for all of France.

## `contractType` (type: `string`):

Filter by contract type.

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

Maximum number of job offers to scrape.

## `fetchDetails` (type: `boolean`):

Fetch each offer's detail page for the full job description, required profile, exact salary range, and company description. Slower and uses more Bright Data requests, but richer. Turn off for faster, listing-only results.

## `brightDataApiKey` (type: `string`):

Bright Data API key for the Web Unlocker zone. Required — Cadremploi is behind a Cloudflare managed challenge and cannot be reached without it. Falls back to the BRIGHT\_DATA\_API\_KEY environment variable.

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

Proxy settings. Cadremploi access itself goes through the Bright Data Web Unlocker; this proxy is accepted for parity and any auxiliary requests.

## Actor input object example

```json
{
  "searchQuery": "comptable",
  "contractType": "all",
  "maxResults": 20,
  "fetchDetails": true,
  "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": "comptable",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cadremploi Scraper - French Executive Cadre Job Offers",
        "description": "Scrape executive (cadre) job offers from Cadremploi (cadremploi.fr), a major French job board for managers and professionals. Search by keyword and contract type. Extract titles, companies, locations, salaries, contract types, full descriptions and required profiles. No login or cookies required.",
        "version": "0.1",
        "x-build-id": "m0xzwhykE66jjYCpe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~cadremploi-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-cadremploi-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~cadremploi-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-cadremploi-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~cadremploi-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-cadremploi-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": "Job search keyword in French (e.g. 'comptable', 'directeur financier', 'chef de projet', 'developpeur'). Leave empty to browse the most recent cadre offers."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filter by city or region name (e.g. 'Paris', 'Lyon', 'Rhone'). Matches the offer location text. Leave empty for all of France."
                    },
                    "contractType": {
                        "title": "Contract Type",
                        "enum": [
                            "all",
                            "CDI",
                            "CDD",
                            "INTERIM",
                            "FREELANCE",
                            "ALTERNANCE",
                            "STAGE"
                        ],
                        "type": "string",
                        "description": "Filter by contract type.",
                        "default": "all"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of job offers to scrape.",
                        "default": 100
                    },
                    "fetchDetails": {
                        "title": "Fetch Full Descriptions",
                        "type": "boolean",
                        "description": "Fetch each offer's detail page for the full job description, required profile, exact salary range, and company description. Slower and uses more Bright Data requests, but richer. Turn off for faster, listing-only results.",
                        "default": true
                    },
                    "brightDataApiKey": {
                        "title": "Bright Data API Key",
                        "type": "string",
                        "description": "Bright Data API key for the Web Unlocker zone. Required — Cadremploi is behind a Cloudflare managed challenge and cannot be reached without it. Falls back to the BRIGHT_DATA_API_KEY environment variable."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Cadremploi access itself goes through the Bright Data Web Unlocker; this proxy is accepted for parity and any auxiliary requests."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
