# PagesJaunes FR $0.8/1K Comprehensive Business Data (`abotapi/pagesjaunes-fr-scraper`) Actor

From $0.8/1K. Scrapes business listings from PagesJaunes.fr (French Yellow Pages). Extract comprehensive business information, including contact details, ratings, reviews, opening hours, payment methods, and category hierarchy across all of France.

- **URL**: https://apify.com/abotapi/pagesjaunes-fr-scraper.md
- **Developed by:** [AbotAPI](https://apify.com/abotapi) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## PagesJaunes FR Business Scraper

Scrapes business listings from PagesJaunes.fr (French Yellow Pages). Extract comprehensive business information including contact details, ratings, reviews, opening hours, payment methods, and category hierarchy across all of France.

### Features

#### Core Capabilities
- **Comprehensive Data Extraction**: Business names, phones, full addresses, ratings, reviews, opening hours, descriptions, payment methods, services, products, website + social profiles, and category breadcrumb
- **Latitude / Longitude**: Attached automatically for every well-matched address — geo-targeting and map plotting ready
- **Two Input Modes**: Search by keyword + location, or paste one or more PagesJaunes search URLs
- **Auto Page Forwarding**: Each URL is crawled forward from its starting page up to your page limit — no need to list every page manually
- **Pagination Support**: Automatically handles multi-page results, with global deduplication across all queries
- **Detail Page Enrichment**: Optional deep scraping for full customer reviews, structured opening hours, and rich business profiles
- **Restaurant Specialty**: Automatic price range and cuisine extraction for dining venues
- **Proxy Support**: Built-in proxy configuration for reliable, uninterrupted scraping

#### Perfect for Lead Generation
- **Direct Contact Information**: Phone numbers and business websites ready for immediate outreach
- **Social Profile Discovery**: Facebook, Instagram, X, LinkedIn, YouTube, and TikTok URLs when the business publishes them
- **Location Intelligence**: Complete structured addresses plus latitude/longitude coordinates for geo-targeting, mapping, and territory assignment
- **Qualified Leads**: Filter by rating, review count, and opening hours to find actively-trading, well-reviewed businesses
- **Category Targeting**: Rich breadcrumb hierarchy lets you segment leads by trade, specialty, and sub-category
- **Service & Product Matching**: Structured lists of services and products let you match leads to specific buyer needs
- **Verification Signals**: Payment methods accepted, opening hours declared, and review counts help validate real, active businesses
- **Market Coverage**: 500+ pages of results for popular categories in major cities — build comprehensive regional lead lists in minutes

#### AI-Ready Data Structure
- **Structured JSON Output**: Clean, consistent data format ready for AI processing, matching, and enrichment pipelines
- **Schema.org Typing**: Each record is tagged with its schema.org business type (Restaurant, LocalBusiness, etc.) for downstream classification
- **Rich Context**: Business descriptions and customer reviews with timestamps — ideal for sentiment analysis, summarization, and RAG
- **Searchable Metadata**: Category breadcrumbs, opening hours, and location fields ready for AI-powered search, recommendation, and matching
- **Training Data**: Comprehensive business profiles suited to training local-business recommendation, review-summarization, and quality-scoring models

### Input Parameters

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `searchTerms` | string | Keyword — e.g. `plombier`, `restaurant`, `dentiste`. Ignored if `startUrls` is provided. | `plombier` |
| `location` | string | City / department / region — e.g. `Paris`, `Lyon`, `75`. Ignored if `startUrls` is provided. | `Paris` |
| `startUrls` | array | Paste one or more PagesJaunes search URLs. Each is auto-crawled forward from its starting page. | `[]` |
| `maxPages` | integer | Maximum pages per query (20 results per page) — 1..100 | `2` |
| `scrapeDetails` | boolean | Fetch each business's detail page for reviews, opening hours, full description | `true` |
| `maxConcurrency` | integer | Concurrent detail requests — 1..20 | `5` |
| `proxy` | object | Recommended. Default proxy configuration is provided. | managed |

#### Using Start URLs

Paste any PagesJaunes search URL and the actor crawls forward from where you pointed it:

```json
{
  "startUrls": [
    {"url": "https://www.pagesjaunes.fr/annuaire/chercherlespros?quoiqui=plombier&ou=Paris"},
    {"url": "https://www.pagesjaunes.fr/annuaire/chercherlespros?quoiqui=restaurant&ou=Lyon&page=3"}
  ],
  "maxPages": 5
}
````

- URL #1 → crawls pages 1–5 of plumbers in Paris.
- URL #2 → crawls pages 3–7 of restaurants in Lyon (auto-forwards from the starting page).
- Businesses that appear in multiple queries are pushed only once (global dedup by client ID).

### Output Format

#### Search-Only Data

Each business record includes:

```json
{
  "clientId": "XXXXXXXX",
  "name": "Sample Business Name",
  "phone": "01 XX XX XX XX",
  "address": "XX rue Example 75001 Paris",
  "activities": ["plombiers"],
  "rating": 4.8,
  "reviewCount": 42,
  "latitude": 48.852000,
  "longitude": 2.350000,
  "detailUrl": "https://www.pagesjaunes.fr/pros/XXXXXXXX",
  "searchTerms": "plombier",
  "searchLocation": "Paris"
}
```

#### Enriched Data (when `scrapeDetails: true`)

Additional fields from the business detail page:

```json
{
  "businessType": "LocalBusiness",
  "fullAddress": {
    "street": "XX rue Example",
    "locality": "Paris",
    "postalCode": "75001",
    "country": null
  },
  "description": "Business description provided by the owner...",
  "website": "https://www.example-business.fr",
  "facebook": "https://www.facebook.com/samplepage",
  "instagram": "https://www.instagram.com/samplehandle",
  "twitter": "https://x.com/samplehandle",
  "linkedin": "https://www.linkedin.com/company/sample",
  "imageUrl": "https://www.pagesjaunes.fr/media/...",
  "photos": [
    "https://www.pagesjaunes.fr/media/.../photo1.jpg",
    "https://www.pagesjaunes.fr/media/.../photo2.jpg"
  ],
  "openingHours": [
    "Mo 08:00-20:00",
    "Tu 08:00-20:00",
    "We 08:00-20:00",
    "Th 08:00-20:00",
    "Fr 08:00-20:00",
    "Sa 09:00-18:00"
  ],
  "paymentAccepted": "CB,Visa,Espèces,Chèque",
  "breadcrumb": [
    "Plombiers",
    "Plombiers à Paris (75)",
    "Dépannage plomberie",
    "Dépannage plomberie à Paris (75)"
  ],
  "services": ["Service A", "Service B", "Service C"],
  "products": ["Product A", "Product B"],
  "reviews": [
    {
      "author": "Customer Name",
      "rating": 5.0,
      "text": "Customer review text...",
      "date": "2025-06-11"
    }
  ]
}
```

#### Restaurant-Only Fields

When scraping restaurants, records include two additional fields:

```json
{
  "priceRange": "21-30 euros",
  "servesCuisine": ["restaurant français"]
}
```

### Example Categories

Popular keyword examples that work out of the box:

- **Trades & Services**: `plombier`, `électricien`, `serrurier`, `menuisier`, `peintre`, `couvreur`
- **Food & Hospitality**: `restaurant`, `boulangerie`, `pâtisserie`, `bar`, `café`, `hôtel`
- **Health & Beauty**: `dentiste`, `médecin`, `pharmacie`, `coiffeur`, `opticien`, `ophtalmologue`
- **Automotive**: `garage automobile`, `carrosserie`, `contrôle technique`, `station service`
- **Retail & Shopping**: `fleuriste`, `boucherie`, `librairie`, `bijouterie`, `magasin de meubles`
- **Professional Services**: `avocat`, `notaire`, `comptable`, `agence immobilière`, `architecte`

Location accepts free text: city names (`Paris`, `Lyon`, `Marseille`), department numbers (`75`, `13`, `69`), or regions (`Île-de-France`, `Provence-Alpes-Côte d'Azur`).

# Actor input Schema

## `searchTerms` (type: `string`):

Business type or keyword to search for. Example: 'plombier', 'restaurant', 'dentiste'. Used only when `startUrls` is empty.

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

Location: city, department number, or region. Example: 'Paris', 'Lyon', '75', 'Ile-de-France'. Used only when `startUrls` is empty.

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

Paste one or more PagesJaunes search URLs. Examples:
• `https://www.pagesjaunes.fr/annuaire/chercherlespros?quoiqui=plombier&ou=Paris`
• `https://www.pagesjaunes.fr/annuaire/chercherlespros?quoiqui=restaurant&ou=Lyon&page=3`

The actor auto-paginates forward from each URL up to `maxPages`. When `startUrls` is non-empty, `searchTerms`+`location` are ignored.

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

Maximum number of search result pages to scrape (20 results per page). Sponsored cards may repeat across pages and are deduped by clientId.

## `scrapeDetails` (type: `boolean`):

Fetch each business's detail page for rich data: full address, opening hours, reviews, payment methods, description. Slower but much more comprehensive.

## `maxConcurrency` (type: `integer`):

Maximum concurrent detail page requests. Lower values are safer against rate limiting.

## `proxy` (type: `object`):

**Required for reliable runs.** A residential proxy is strongly recommended — the site blocks most non-residential IPs. Leave the default selection to let the actor rotate sticky sessions across a pool of reliable locations automatically.

## Actor input object example

```json
{
  "searchTerms": "plombier",
  "location": "Paris",
  "startUrls": [],
  "maxPages": 2,
  "scrapeDetails": true,
  "maxConcurrency": 5,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `businesses` (type: `string`):

Individual business records with contact info, ratings, reviews, and location data

# 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 = {
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/pagesjaunes-fr-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 = { "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    } }

# Run the Actor and wait for it to finish
run = client.actor("abotapi/pagesjaunes-fr-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 '{
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call abotapi/pagesjaunes-fr-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PagesJaunes FR $0.8/1K Comprehensive Business Data",
        "description": "From $0.8/1K. Scrapes business listings from PagesJaunes.fr (French Yellow Pages). Extract comprehensive business information, including contact details, ratings, reviews, opening hours, payment methods, and category hierarchy across all of France.",
        "version": "0.1",
        "x-build-id": "DdZq2n18f7tDC1Zol"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~pagesjaunes-fr-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-pagesjaunes-fr-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/abotapi~pagesjaunes-fr-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-pagesjaunes-fr-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/abotapi~pagesjaunes-fr-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-pagesjaunes-fr-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",
                "required": [
                    "searchTerms",
                    "location"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms (quoiqui)",
                        "type": "string",
                        "description": "Business type or keyword to search for. Example: 'plombier', 'restaurant', 'dentiste'. Used only when `startUrls` is empty.",
                        "default": "plombier"
                    },
                    "location": {
                        "title": "Location (ou)",
                        "type": "string",
                        "description": "Location: city, department number, or region. Example: 'Paris', 'Lyon', '75', 'Ile-de-France'. Used only when `startUrls` is empty.",
                        "default": "Paris"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste one or more PagesJaunes search URLs. Examples:\n• `https://www.pagesjaunes.fr/annuaire/chercherlespros?quoiqui=plombier&ou=Paris`\n• `https://www.pagesjaunes.fr/annuaire/chercherlespros?quoiqui=restaurant&ou=Lyon&page=3`\n\nThe actor auto-paginates forward from each URL up to `maxPages`. When `startUrls` is non-empty, `searchTerms`+`location` are ignored.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxPages": {
                        "title": "Maximum Pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of search result pages to scrape (20 results per page). Sponsored cards may repeat across pages and are deduped by clientId.",
                        "default": 2
                    },
                    "scrapeDetails": {
                        "title": "Scrape Detail Pages",
                        "type": "boolean",
                        "description": "Fetch each business's detail page for rich data: full address, opening hours, reviews, payment methods, description. Slower but much more comprehensive.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum concurrent detail page requests. Lower values are safer against rate limiting.",
                        "default": 5
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "**Required for reliable runs.** A residential proxy is strongly recommended — the site blocks most non-residential IPs. Leave the default selection to let the actor rotate sticky sessions across a pool of reliable locations automatically.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
