# France Travail Jobs Scraper - French Job Data (`benthepythondev/france-travail-jobs-scraper`) Actor

Scrape France Travail jobs with titles, employers, descriptions, salary, skills, contract, location, dates and public employer contacts.

- **URL**: https://apify.com/benthepythondev/france-travail-jobs-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## France Travail Jobs Scraper - French Job Data

Collect structured vacancies from **France Travail**, France's public employment service and the successor to Pôle emploi. Search by role or skill and French location code, preserve filters from a public search URL, paginate through current offers, and optionally enrich every result from the public vacancy page.

The Actor returns job titles, employers, locations, contracts, descriptions, salary ranges, skills, experience, dates, industry, employer logos and public contact details when they are disclosed in the listing. Results can be exported to JSON, CSV, Excel or XML, scheduled as a recurring feed, or consumed through the Apify API.

### What can you use this Actor for?

- Monitor new French vacancies by occupation, skill, employer or department.
- Build job alerts for recruiting, staffing, career and labor-market products.
- Identify companies with active hiring demand as a business-intent signal.
- Compare salaries, contracts and required skills across regions or role families.
- Track CDI, CDD, apprenticeship, internship and partner-board job supply.
- Create employer research lists from contacts published in vacancy pages.
- Feed dashboards, spreadsheets, warehouses, CRMs, Make, Zapier or n8n.
- Preserve a daily or weekly snapshot for longitudinal employment analysis.

### Why use France Travail data?

France Travail is a national public employment source rather than a small specialist board. Its search covers direct employer offers and, when requested, listings supplied by partner job sites. That breadth makes it useful for regional labor-market measurement, recurring vacancy feeds and employer-level hiring research.

The public detail pages use structured JobPosting metadata. Depending on the vacancy, that metadata includes a complete employer-supplied description, postal code, city, region, employment type, working hours, publication and expiry dates, salary range and period, experience, skills, qualification, industry and hiring organization. The Actor converts those source values into stable English field names without inventing missing information.

### Input

The bounded default searches for `développeur Python` in location code `75D` (Paris department), includes partner offers, enriches details and saves up to 10 jobs. This small default is designed to finish quickly in Apify's automated quality checks.

| Field | Purpose |
|---|---|
| `searchUrls` | Optional public France Travail search URLs with filters already applied. |
| `keywords` | French or English role, skill, occupation or employer terms. |
| `locationCodes` | France Travail codes such as `75D`, `69D` or `13D`. |
| `radiusKm` | Distance around each requested location. |
| `includePartnerOffers` | Include offers supplied by partner job boards. |
| `sort` | Order by relevance or newest publication date. |
| `includeDetails` | Fetch full descriptions, salary, skills and public contacts. |
| `maxResultsPerSearch` | Maximum unique results for every search target. |
| `maxPagesPerSearch` | Safety limit for sticky-session pagination. |

Use a copied search URL when you need filters that are easier to select on the France Travail website. Keyword and location-code inputs are convenient for automated tasks and API calls. If both modes are supplied, all searches run and overlapping offer references are returned once.

#### Example input

```json
{
  "keywords": ["développeur Python", "data engineer"],
  "locationCodes": ["75D", "69D"],
  "radiusKm": 25,
  "includePartnerOffers": true,
  "sort": "date",
  "includeDetails": true,
  "maxResultsPerSearch": 25,
  "maxPagesPerSearch": 5
}
````

For a pre-filtered website search, use:

```json
{
  "searchUrls": [
    {"url": "https://candidat.francetravail.fr/offres/recherche?motsCles=data&lieux=75D"}
  ],
  "keywords": [],
  "locationCodes": [],
  "includeDetails": true,
  "maxResultsPerSearch": 20
}
```

### Output

Each dataset row represents one public vacancy. Common fields include:

- `reference`, `url`, `application_url`
- `title`, `employer`, `employer_logo`
- `location`, `postal_code`, `city`, `region`, `country`
- `description`, `snippet`
- `contract_type`, `employment_type`, `work_time`, `work_hours`
- `salary_text`, `salary_min`, `salary_max`, `salary_currency`, `salary_period`
- `experience`, `skills`, `qualification`, `industry`
- `published_at`, `published_text`, `valid_through`
- `contact_emails`, `contact_phones`, `lead_score`
- `source_listing_origin`, `source_query`, `search_url`, `search_rank`, `scraped_at`

#### Example result

```json
{
  "reference": "209YVYD",
  "title": "Developpeur informatique spécialisé en finance (H/F)",
  "employer": "LUNALOGIC",
  "location": "75 - PARIS",
  "postal_code": "75002",
  "city": "Paris",
  "region": "Île-de-France",
  "contract_type": "CDI",
  "employment_type": "FULL_TIME",
  "salary_min": "40000.0",
  "salary_max": "55000.0",
  "salary_currency": "EUR",
  "salary_period": "YEAR",
  "published_at": "2026-06-18",
  "url": "https://candidat.francetravail.fr/offres/recherche/detail/209YVYD"
}
```

The example shows the shape of a real public vacancy, but live offers change continuously. Missing salary, contact, employer or skill fields remain empty rather than being guessed.

### Contact and lead fields

When detail enrichment is enabled, the Actor reads contact values from the public hiring-organization metadata and scans the employer-supplied description for French phone and email patterns. It does not log into a candidate account, buy private enrichment data or generate probable email addresses.

`lead_score` is a transparent completeness score. It rewards a named employer, public email or phone, full description, salary, skills, publication date and canonical URL. It is useful for sorting research rows, but it does not predict an employer's willingness to respond and should not replace human qualification.

### Reliable extraction design

The search page is server rendered, so the Actor does not need a browser or paid proxy. France Travail pagination uses a stateful Tapestry endpoint: the Actor first loads the public search page, preserves its session cookies, then follows the source-provided pagination link and parses each returned result fragment. This is more reliable than fabricating page URLs.

Detail requests run concurrently behind a strict semaphore. Temporary request failures are retried, records are deduplicated by the official offer reference, limits are bounded, and a run fails visibly when no usable jobs are returned. A successful process with an empty dataset is not treated as healthy.

### Scheduling and integrations

For a daily hiring monitor, sort by date and keep a narrow result limit for each role and department. Store `reference` as the external primary key, then alert only when a new value appears. For salary or skill analysis, schedule a broader weekly snapshot and group rows by `region`, `contract_type`, `salary_period`, `skills` or `employer`.

Apify can export the default dataset directly or send run-completion webhooks into Make, Zapier and n8n. CSV and Excel are useful for analyst review; JSON is better for repeatable application and warehouse pipelines.

### Pricing

The Actor uses transparent pay-per-event pricing. A very small start event covers initialization, and every unique vacancy written to the default dataset is billed as one `result`. Duplicate jobs discarded before output are not billed again. The result limit gives direct control over the maximum number of billable rows.

### Responsible use

This Actor collects public vacancy and employer information. Use it for legitimate recruitment, aggregation, labor-market research and monitoring. Follow applicable privacy, employment, database and marketing rules. Verify time-sensitive details on the canonical France Travail page before applying, contacting an employer or making decisions.

### FAQ

#### Is a France Travail account or API credential required?

No. The Actor reads public search and vacancy pages without a user login, OAuth client or external API key.

#### Where do location codes come from?

France Travail encodes selected areas in the `lieux` query parameter. The simplest method is to choose a location on the public website and copy the resulting search URL. Common department examples include `75D` for Paris, `69D` for Rhône and `13D` for Bouches-du-Rhône.

#### Can I collect several roles and regions?

Yes. Add multiple `keywords` and `locationCodes`. Every combination runs independently, and duplicate offer references are returned once.

#### Why are salary or contact fields empty?

Not every employer publishes them. The Actor only returns source-visible values and never fabricates missing data.

#### Can I skip detail pages for speed?

Yes. Set `includeDetails` to `false` for lightweight search rows. Full salary, skills, description, exact dates and contacts generally require detail enrichment.

#### How do I prevent duplicates across scheduled runs?

Use `reference` as the primary key in your destination. The Actor deduplicates within one run; a database, spreadsheet automation or workflow can use the same reference across runs.

#### What should I include in a support issue?

Include a small input, the Apify run URL and the expected behavior. Do not include candidate credentials or private personal data.

### You might also like

- [Arbeitsagentur Jobs Scraper](https://apify.com/benthepythondev/arbeitsagentur-jobs-scraper) for Germany's federal employment data.
- [Welcome to the Jungle Jobs Scraper](https://apify.com/benthepythondev/welcome-to-the-jungle-jobs-scraper) for European startup and employer-profile jobs.
- [StepStone Scraper](https://apify.com/benthepythondev/stepstone-scraper) for commercial European job-board listings.
- [Wellfound Jobs Scraper](https://apify.com/benthepythondev/wellfound-jobs-scraper) for startup roles, salary and equity data.
- [Remote Jobs Aggregator](https://apify.com/benthepythondev/remote-jobs-aggregator) for multi-source remote vacancies.

If this Actor saves you time, please leave a review on its Apify Store page. Reviews help prioritize reliability work and requested features.

**Keywords:** France Travail scraper, Pôle emploi scraper, French jobs API, France jobs scraper, emploi scraper, France Travail jobs data, recruitment data France, French labor market, CDI jobs scraper, CDD jobs scraper, salary data France, employer lead generation, Apify jobs scraper

# Actor input Schema

## `searchUrls` (type: `array`):

Optional public France Travail offers/recherche URLs. Use these to preserve filters selected on the website.

## `keywords` (type: `array`):

French or English role, skill, occupation or employer terms.

## `locationCodes` (type: `array`):

Location codes used by France Travail, such as 75D for Paris department, 69D for Rhône or 13D for Bouches-du-Rhône.

## `radiusKm` (type: `integer`):

Distance around each requested location code.

## `includePartnerOffers` (type: `boolean`):

Include offers supplied to France Travail by approved partner job boards.

## `sort` (type: `string`):

Sort search results by relevance or publication date.

## `includeDetails` (type: `boolean`):

Enrich every row with full description, salary, skills, dates, employer metadata and public contacts.

## `maxResultsPerSearch` (type: `integer`):

Maximum unique jobs saved for each URL or keyword/location combination.

## `maxPagesPerSearch` (type: `integer`):

Safety cap for sticky-session pagination. Each source page contains up to 20 jobs.

## Actor input object example

```json
{
  "searchUrls": [],
  "keywords": [
    "développeur Python",
    "data engineer"
  ],
  "locationCodes": [
    "75D",
    "69D"
  ],
  "radiusKm": 10,
  "includePartnerOffers": true,
  "sort": "relevance",
  "includeDetails": true,
  "maxResultsPerSearch": 10,
  "maxPagesPerSearch": 25
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchUrls": [],
    "keywords": [
        "développeur Python",
        "data engineer"
    ],
    "locationCodes": [
        "75D",
        "69D"
    ],
    "radiusKm": 10,
    "includePartnerOffers": true,
    "sort": "relevance",
    "includeDetails": true,
    "maxResultsPerSearch": 10,
    "maxPagesPerSearch": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/france-travail-jobs-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 = {
    "searchUrls": [],
    "keywords": [
        "développeur Python",
        "data engineer",
    ],
    "locationCodes": [
        "75D",
        "69D",
    ],
    "radiusKm": 10,
    "includePartnerOffers": True,
    "sort": "relevance",
    "includeDetails": True,
    "maxResultsPerSearch": 10,
    "maxPagesPerSearch": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/france-travail-jobs-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 '{
  "searchUrls": [],
  "keywords": [
    "développeur Python",
    "data engineer"
  ],
  "locationCodes": [
    "75D",
    "69D"
  ],
  "radiusKm": 10,
  "includePartnerOffers": true,
  "sort": "relevance",
  "includeDetails": true,
  "maxResultsPerSearch": 10,
  "maxPagesPerSearch": 25
}' |
apify call benthepythondev/france-travail-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "France Travail Jobs Scraper - French Job Data",
        "description": "Scrape France Travail jobs with titles, employers, descriptions, salary, skills, contract, location, dates and public employer contacts.",
        "version": "1.0",
        "x-build-id": "89NbTfEfLuCRPu9NP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~france-travail-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-france-travail-jobs-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/benthepythondev~france-travail-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-france-travail-jobs-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/benthepythondev~france-travail-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-france-travail-jobs-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": {
                    "searchUrls": {
                        "title": "France Travail search URLs",
                        "type": "array",
                        "description": "Optional public France Travail offers/recherche URLs. Use these to preserve filters selected on the website.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keywords": {
                        "title": "Job keywords",
                        "type": "array",
                        "description": "French or English role, skill, occupation or employer terms.",
                        "default": [
                            "développeur Python"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationCodes": {
                        "title": "France Travail location codes",
                        "type": "array",
                        "description": "Location codes used by France Travail, such as 75D for Paris department, 69D for Rhône or 13D for Bouches-du-Rhône.",
                        "default": [
                            "75D"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "radiusKm": {
                        "title": "Search radius in kilometers",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Distance around each requested location code.",
                        "default": 10
                    },
                    "includePartnerOffers": {
                        "title": "Include partner offers",
                        "type": "boolean",
                        "description": "Include offers supplied to France Travail by approved partner job boards.",
                        "default": true
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Sort search results by relevance or publication date.",
                        "default": "relevance"
                    },
                    "includeDetails": {
                        "title": "Fetch full job details",
                        "type": "boolean",
                        "description": "Enrich every row with full description, salary, skills, dates, employer metadata and public contacts.",
                        "default": true
                    },
                    "maxResultsPerSearch": {
                        "title": "Maximum jobs per search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum unique jobs saved for each URL or keyword/location combination.",
                        "default": 10
                    },
                    "maxPagesPerSearch": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Safety cap for sticky-session pagination. Each source page contains up to 20 jobs.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
