# Pages Jaunes France Business Scraper (`automation-lab/pagesjaunes-france-business-scraper`) Actor

Scrape business listings, phone numbers, emails, websites and addresses from PagesJaunes.fr — France's leading business directory

- **URL**: https://apify.com/automation-lab/pagesjaunes-france-business-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Pages Jaunes France Business Scraper

Extract business listings, phone numbers, addresses, emails, websites, and ratings from [PagesJaunes.fr](https://www.pagesjaunes.fr) — France's largest business directory with over 3 million professional listings.

### 🗂️ What does it do?

This actor scrapes business data from PagesJaunes.fr (the French yellow pages) by keyword and location. You provide a profession or keyword and a city or region, and the actor returns a structured list of matching businesses with their contact details.

Whether you need plumbers in Lyon, restaurants in Paris, or accountants in Bordeaux, this scraper retrieves the complete business profile from France's most comprehensive professional directory.

### 👥 Who is it for?

**Sales and lead generation teams** building prospect lists of French businesses by industry and region — skip the manual copy-paste and automate your outreach pipeline.

**Marketing agencies** conducting market research on local business density, competitor mapping, or territory analysis across French cities and departments.

**B2B SaaS companies** enriching CRM records with French business contact data — phone numbers, addresses, and categories for companies you already know about.

**Data analysts and researchers** studying the French SME landscape — restaurant density by arrondissement, healthcare provider coverage by commune, etc.

**Freelancers and consultants** prospecting for clients in specific trades or professions (avocat, architecte, expert-comptable) across target locations.

### ✅ Why use it?

- **No manual scraping** — automated extraction of 100s of listings per run
- **Phone numbers included** — direct telephone contacts, not obfuscated
- **Postal code parsing** — addresses split into street, city, and postal code
- **Category extraction** — know exactly what type of business each listing is
- **Pagination handled** — automatically follows next-page links to retrieve all results
- **Cloudflare-resistant** — uses browser-based rendering with residential proxy to bypass bot protection

### 📊 Data extracted

| Field | Description | Example |
|-------|-------------|---------|
| `businessName` | Full company/professional name | "Le Sirocco" |
| `phone` | Primary phone number | "01 43 31 13 13" |
| `email` | Email address (if publicly listed) | "contact@example.fr" |
| `website` | Business website URL | "https://lesirocco.fr" |
| `address` | Street address | "8 Bis rue Gobelins" |
| `city` | City name | "Paris" |
| `postalCode` | French postal code (5 digits) | "75013" |
| `category` | Business category/profession | "restaurants" |
| `description` | Business description/tagline | "Restaurant marocain traditionnel..." |
| `rating` | Customer rating (1–5) | 4.3 |
| `reviewCount` | Number of reviews | 1042 |
| `url` | Direct link to PagesJaunes profile | "https://www.pagesjaunes.fr/pros/..." |
| `searchTerms` | The keyword used to find this result | "restaurant" |
| `location` | The location searched | "Paris" |

### 💰 How much does it cost to scrape PagesJaunes.fr?

This actor uses **pay-per-event (PPE) pricing**:

- **Start fee**: $0.005 per run (one-time)
- **Per result**: from $0.00065 to $0.00268 per business extracted (varies by subscription tier)

| Subscription tier | Price per result |
|---|---|
| Free | $0.00268 |
| Bronze | $0.00233 |
| Silver | $0.00182 |
| Gold | $0.00140 |
| Platinum | $0.00093 |
| Diamond | $0.00065 |

**Example cost estimates (Bronze tier):**
- 100 businesses: ~$0.24 total
- 500 businesses: ~$1.17 total
- 1,000 businesses: ~$2.33 total

Pricing is based on actual infrastructure cost measurements with 70%+ net margins built in. Compare with competitors charging between $0.001 and $0.004 per result flat.

**Free plan estimate:** Apify's free tier ($5/month credit) can extract approximately 1,800–2,000 business listings per month.

### 🚀 How to use it

1. **Open the actor** on Apify and click **Try for free**
2. Set your **search keyword** — the profession or business type (e.g., `restaurant`, `plombier`, `dentiste`, `avocat`)
3. Set your **location** — city, department, or postal code (e.g., `Paris`, `Lyon`, `75001`)
4. Set **maximum results** — how many businesses to extract
5. Click **Start** and wait for results

The actor handles Cloudflare automatically. Most runs complete in 2–5 minutes for 100 listings.

### ⚙️ Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `searchTerms` | string | ✅ Yes | — | Keyword/profession to search for |
| `location` | string | ✅ Yes | — | City, region, or postal code |
| `maxResults` | integer | No | 50 | Maximum number of results to extract |
| `proxyCountry` | string | No | "FR" | Proxy country code (FR recommended) |

#### 🔍 Search tips

- Use **French terms**: `plombier` not `plumber`, `boulangerie` not `bakery`
- Use **NAF codes** if you know them (e.g., `56.10A` for restaurants)
- Location accepts: city name (`Bordeaux`), department (`Gironde`), region (`Nouvelle-Aquitaine`), or postal code (`33000`)
- For broad searches across France, use `France` as the location

### 📤 Output format

Results are stored in the default dataset as JSON. Each item represents one business:

```json
{
    "businessName": "Le Sirocco",
    "phone": "01 43 31 13 13",
    "email": null,
    "website": "https://www.lesirocco.fr",
    "address": "8 Bis rue Gobelins",
    "city": "Paris",
    "postalCode": "75013",
    "category": "restaurants",
    "description": "Venez découvrir la gastronomie marocaine...",
    "rating": 4.3,
    "reviewCount": 1042,
    "url": "https://www.pagesjaunes.fr/pros/08154320",
    "searchTerms": "restaurant",
    "location": "Paris"
}
````

### 💡 Tips and best practices

- **Start small**: Run with `maxResults: 20` first to verify the data matches your needs before scaling up
- **Multiple searches**: Run separate actor instances for each profession/location combination rather than one huge run
- **Use French terms**: PagesJaunes is entirely in French — search exactly as a French user would
- **Batch by department**: For national data, run one search per French department (there are 95) rather than using `France` — this gives more targeted results
- **Phone cleanup**: Phone numbers are extracted as-is from the page; normalize them in post-processing (remove spaces, normalize to E.164 format if needed)
- **Proxy country**: Keep `proxyCountry: "FR"` — using a French IP gives more accurate local results

### 🔗 Integrations

#### Export to Google Sheets

After your run completes, use **Apify's Google Sheets integration** to push all results directly to a spreadsheet:

1. Go to your dataset → **Export** → **Google Sheets**
2. Authorize your Google account
3. All business fields appear as columns automatically

#### CRM enrichment (HubSpot, Salesforce)

Use Apify's **Zapier** or **Make** integration to push each extracted business directly to your CRM:

- Trigger: `Actor run finished`
- Action: `Create contact in HubSpot`
- Map: `businessName → Company Name`, `phone → Phone`, `city → City`

#### Airtable database

Connect to Airtable via the **Apify Airtable integration** — perfect for territory mapping or sales team assignments where you want a filterable, shareable database.

#### Combine with email finder

After extracting businesses with this actor, pass the company names + domains to an email finder actor (like Hunter.io Scraper on Apify Store) to append email addresses where not directly available on PagesJaunes.

### 🤖 API usage

#### Node.js

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

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

const run = await client.actor('automation-lab/pagesjaunes-france-business-scraper').call({
    searchTerms: 'restaurant',
    location: 'Lyon',
    maxResults: 100,
    proxyCountry: 'FR',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Extracted ${items.length} businesses`);
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_API_TOKEN')

run = client.actor('automation-lab/pagesjaunes-france-business-scraper').call(run_input={
    'searchTerms': 'plombier',
    'location': 'Marseille',
    'maxResults': 50,
    'proxyCountry': 'FR',
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(f'Extracted {len(items)} businesses')
for biz in items:
    print(biz['businessName'], biz['phone'], biz['city'])
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~pagesjaunes-france-business-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchTerms": "dentiste",
    "location": "Paris",
    "maxResults": 50,
    "proxyCountry": "FR"
  }'
```

### 🤖 Use with Claude (MCP)

This actor is available as a tool in Claude AI via the **Model Context Protocol (MCP)**. Ask Claude to find French business leads directly in your conversation.

#### Claude Code (terminal)

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/pagesjaunes-france-business-scraper"
```

#### Claude Desktop / Cursor / VS Code

Add to your MCP config file (`claude_desktop_config.json` or similar):

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com?tools=automation-lab/pagesjaunes-france-business-scraper",
            "headers": {
                "Authorization": "Bearer YOUR_APIFY_API_TOKEN"
            }
        }
    }
}
```

#### Example prompts for Claude

- *"Find all plumbers in Lyon and export to CSV"*
- *"Scrape 200 restaurants in Paris 75001 and 75002 postcodes"*
- *"Get dentists in Marseille with their phone numbers for our CRM"*
- *"Extract accounting firms in Bordeaux region — I need 500 leads"*

### ⚖️ Legality and terms of service

PagesJaunes.fr makes business contact information publicly available for the purpose of connecting users with professionals. Scraping this publicly available directory data for lead generation, market research, and business intelligence purposes is a common and widely-practiced use case.

However, you should be aware of:

- **GDPR compliance**: Data about individuals (sole traders) may constitute personal data under GDPR. Ensure you have a legitimate purpose and handle data according to EU regulations.
- **PagesJaunes terms of service**: Commercial mass extraction may be against PagesJaunes' terms of service. Review their ToS before large-scale operations.
- **Purpose limitation**: Use extracted data only for the purpose you collected it for.
- **Data retention**: Don't store data longer than necessary for your purpose.

This actor is provided for research, prospecting, and data analysis purposes. Users are responsible for complying with applicable laws and platform terms.

### ❓ FAQ

**Q: Why am I getting 0 results?**

A: Try using French language search terms (e.g., `boulangerie` not `bakery`). If results are still empty, the combination of keyword + location may return 0 results on PagesJaunes — try a broader location like a full department or region name.

**Q: The actor is slow — is this normal?**

A: Yes, PagesJaunes uses Cloudflare protection which requires browser-based rendering. Each page takes 5–15 seconds to load. For 100 results (5 pages), expect 60–90 seconds total runtime.

**Q: Phone numbers are missing for some results — why?**

A: Some businesses haven't listed a phone number on PagesJaunes, or only show it after clicking a "reveal" button (which requires an additional browser interaction). The actor extracts phones that are pre-loaded in the page HTML.

**Q: Can I scrape all of France at once?**

A: Yes, but we recommend splitting by department (95 total) and running parallel actor instances rather than one enormous run. This distributes cost and avoids timeouts.

**Q: The actor failed mid-run — what happened?**

A: Most failures are caused by Cloudflare challenges timing out. The actor automatically retries with a fresh browser session. If failures persist, try reducing `maxResults` or switching the `proxyCountry` to `FR`.

**Q: Can I get email addresses?**

A: Some businesses list their email directly on PagesJaunes and it will be extracted. Most do not — for email discovery, combine this actor with an email finder service.

### 🔗 Related scrapers

- [automation-lab/yellowpages-scraper](https://apify.com/automation-lab/yellowpages-scraper) — US business directory
- [automation-lab/google-maps-scraper](https://apify.com/automation-lab/google-maps-scraper) — Google Maps business data
- [automation-lab/linkedin-company-scraper](https://apify.com/automation-lab/linkedin-company-scraper) — LinkedIn company profiles

# Actor input Schema

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

Profession, business name, or keyword to search for (e.g. 'restaurant', 'plombier', 'dentiste', 'avocat').

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

City, department, region, or postal code to search in (e.g. 'Paris', 'Lyon', 'Marseille', '75001').

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

Maximum number of business listings to extract. Keep low for testing to minimize cost.

## `proxyCountry` (type: `string`):

ISO country code for residential proxy (FR recommended for best results with PagesJaunes.fr).

## Actor input object example

```json
{
  "searchTerms": "restaurant",
  "location": "Paris",
  "maxResults": 20,
  "proxyCountry": "FR"
}
```

# Actor output Schema

## `overview` (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 = {
    "searchTerms": "restaurant",
    "location": "Paris",
    "maxResults": 20,
    "proxyCountry": "FR"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/pagesjaunes-france-business-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 = {
    "searchTerms": "restaurant",
    "location": "Paris",
    "maxResults": 20,
    "proxyCountry": "FR",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/pagesjaunes-france-business-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 '{
  "searchTerms": "restaurant",
  "location": "Paris",
  "maxResults": 20,
  "proxyCountry": "FR"
}' |
apify call automation-lab/pagesjaunes-france-business-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pages Jaunes France Business Scraper",
        "description": "Scrape business listings, phone numbers, emails, websites and addresses from PagesJaunes.fr — France's leading business directory",
        "version": "0.1",
        "x-build-id": "krYitomt1n3NDWJtm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~pagesjaunes-france-business-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-pagesjaunes-france-business-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/automation-lab~pagesjaunes-france-business-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-pagesjaunes-france-business-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/automation-lab~pagesjaunes-france-business-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-pagesjaunes-france-business-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": "🔍 What to search (profession/business type)",
                        "type": "string",
                        "description": "Profession, business name, or keyword to search for (e.g. 'restaurant', 'plombier', 'dentiste', 'avocat')."
                    },
                    "location": {
                        "title": "📍 Location (city, region, or postal code)",
                        "type": "string",
                        "description": "City, department, region, or postal code to search in (e.g. 'Paris', 'Lyon', 'Marseille', '75001')."
                    },
                    "maxResults": {
                        "title": "📊 Maximum results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of business listings to extract. Keep low for testing to minimize cost."
                    },
                    "proxyCountry": {
                        "title": "🌍 Proxy country code",
                        "type": "string",
                        "description": "ISO country code for residential proxy (FR recommended for best results with PagesJaunes.fr)."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```