# APEC Jobs Scraper (`automation-lab/apec-jobs-scraper`) Actor

Scrape APEC.fr executive jobs by keyword, location, salary, contract type, and freshness with descriptions, skills, and apply URLs.

- **URL**: https://apify.com/automation-lab/apec-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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

## APEC Jobs Scraper

Extract executive and cadre job offers from APEC.fr with clean recruiter-ready fields.

APEC Jobs Scraper is an Apify Actor for collecting French APEC job listings by keyword, location, department, contract filters, salary filters, and posting freshness. It returns structured records with titles, companies, locations, salary text, publication dates, job URLs, application links, descriptions, profile requirements, company text, skills, and recruiter/contact names when APEC exposes them publicly.

### What does APEC Jobs Scraper do?

APEC Jobs Scraper turns public APEC.fr search results into a structured dataset.

It can:

- 🔎 Search APEC jobs by keyword such as `data`, `directeur financier`, or `product manager`.
- 📍 Filter by APEC location or department IDs such as `75` for Paris.
- 📄 Fetch detail records for full job descriptions and profile requirements.
- 🧑‍💼 Extract public recruiter names when visible in the APEC detail response.
- 🧠 Extract skills listed by APEC for each job offer.
- 🕒 Support incremental monitoring with `incrementalSince`.
- 🔗 Preserve source URLs and source query metadata for audits.

### Who is it for?

This actor is built for teams that monitor French executive hiring demand.

Typical users include:

- 🧑‍💼 Recruiters monitoring APEC executive openings.
- 🏢 Staffing agencies building lead lists for hiring companies.
- 📊 Labor-market intelligence teams tracking demand by role and region.
- 📰 Job boards enriching their French cadre job inventory.
- 🤖 Automation teams feeding jobs into CRMs, spreadsheets, alerts, or databases.

### Why use it?

APEC search pages are designed for humans, not repeatable pipelines. This actor wraps the public APEC job search API and normalizes the result into a dataset that can be exported as JSON, CSV, Excel, RSS, or sent to integrations.

Use it when you need repeatable extraction, deduplication keys, and stable field names instead of manual copy-paste from APEC.fr.

### Data you can extract

| Field | Description |
| --- | --- |
| `offerNumber` | Public APEC offer number |
| `title` | Job title |
| `company` | Company or establishment name |
| `location` | Primary location |
| `locations` | All public APEC locations |
| `salaryText` | Salary text shown by APEC |
| `publicationDate` | Latest publication date |
| `firstPublicationDate` | First publication date when available |
| `jobUrl` | APEC detail URL |
| `applicationUrl` | APEC application URL |
| `descriptionText` | Clean text job description |
| `descriptionHtml` | Original public HTML description |
| `profileText` | Candidate profile section |
| `companyDescriptionText` | Company presentation text |
| `skills` | Skills exposed by APEC |
| `recruiterName` | Public recruiter name when visible |
| `sourceQuery` | Search criteria used to find the job |

### How much does it cost to scrape APEC jobs?

The actor uses pay-per-event pricing.

- Start event: a small one-time run fee.
- Item event: charged per saved APEC job offer.

The default package contains tiered PPE pricing. Final prices are validated from cloud run costs before QA handoff and kept synchronized with platform pricing.

### Input options

You can run the actor with either APEC search URLs or explicit criteria.

#### APEC search URLs

Paste one or more URLs from APEC search, for example:

```json
{
  "startUrls": [
    { "url": "https://www.apec.fr/candidat/recherche-emploi.html/emploi?motsCles=data&lieux=75" }
  ],
  "maxItems": 100,
  "fetchDetails": true
}
````

#### Keyword search

Use keywords and location IDs directly:

```json
{
  "keywords": ["data", "product manager"],
  "locations": ["75"],
  "maxItems": 100,
  "fetchDetails": true
}
```

### Advanced filters

The actor accepts raw APEC nomenclature IDs for advanced filters.

- `contractTypeIds`
- `experienceLevelIds`
- `sectorIds`
- `teleworkTypeIds`
- `minSalaryKeur`
- `maxSalaryKeur`
- `postedSince`

The easiest way to discover exact APEC IDs is to set filters on APEC.fr and paste the resulting search URL into `startUrls`.

### Incremental monitoring

Use `incrementalSince` to skip jobs older than a date.

Example:

```json
{
  "keywords": ["data engineer"],
  "locations": ["75"],
  "incrementalSince": "2026-01-01T00:00:00Z",
  "maxItems": 250
}
```

This is useful for scheduled runs where you only want newly published offers.

### Output example

```json
{
  "offerNumber": "178952014W",
  "title": "Expert·e Systèmes Linux - CDI F/H",
  "company": "BLUE SOFT",
  "location": "Paris 01 - 75",
  "salaryText": "A négocier",
  "publicationDate": "2026-06-26T21:05:05.000+0000",
  "jobUrl": "https://www.apec.fr/candidat/recherche-emploi.html/emploi/detail-offre/178952014W",
  "skills": ["Mesure de la performance"],
  "sourceQuery": { "keywords": "data", "locations": ["75"] }
}
```

### How to run

1. Open the actor on Apify.
2. Paste an APEC search URL or enter keywords.
3. Set `maxItems`.
4. Keep `fetchDetails` enabled if you need full descriptions and skills.
5. Run the actor.
6. Export the dataset or connect it to an integration.

### Tips for better results

- ✅ Start with a real APEC search URL when you need exact filters.
- ✅ Keep `maxItems` small for testing.
- ✅ Use `incrementalSince` for daily monitoring.
- ✅ Turn off `fetchDetails` for faster listing-only scans.
- ✅ Use `offerNumber` as the deduplication key in downstream systems.

### Integrations

APEC Jobs Scraper works with Apify integrations and webhooks.

Common workflows:

- Send new APEC jobs to Google Sheets.
- Push executive hiring leads into Airtable.
- Trigger Slack alerts for new jobs matching a keyword.
- Store daily snapshots in a data warehouse.
- Enrich CRM accounts with current hiring demand.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/apec-jobs-scraper').call({
  keywords: ['data'],
  locations: ['75'],
  maxItems: 100,
  fetchDetails: true,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/apec-jobs-scraper').call(run_input={
    'keywords': ['data'],
    'locations': ['75'],
    'maxItems': 100,
    'fetchDetails': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~apec-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["data"],"locations":["75"],"maxItems":100,"fetchDetails":true}'
```

### MCP usage

Use the Apify MCP server to call the actor from Claude Desktop or Claude Code.

Add the actor tool in Claude Code:

```bash
claude mcp add apify-apec-jobs "https://mcp.apify.com/?tools=automation-lab/apec-jobs-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-apec-jobs": {
      "url": "https://mcp.apify.com/?tools=automation-lab/apec-jobs-scraper"
    }
  }
}
```

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/apec-jobs-scraper
```

Example prompts:

- "Find the newest APEC data jobs in Paris and return company names."
- "Monitor APEC product manager jobs since yesterday."
- "Extract full descriptions for the first 50 APEC finance executive roles."

### Reliability notes

The actor uses APEC public JSON endpoints that are loaded by the APEC web application. It does not require private cookies or an APEC account for public job search and public offer detail data.

If APEC changes its public API, the actor may need an update. Use smaller runs first when testing a new filter combination.

### Limitations

- It only extracts public information visible through APEC public endpoints.
- Advanced filters use APEC internal nomenclature IDs.
- It does not apply to jobs that are removed or unpublished by APEC.
- Contact details are returned only when publicly exposed by APEC.

### Legality

This actor extracts publicly available APEC job information. You are responsible for using the data lawfully, respecting APEC terms, privacy rules, and applicable employment-data regulations. Avoid collecting or processing personal data unless you have a valid legal basis.

### FAQ

#### Why did I get fewer jobs than expected?

APEC may have fewer matching offers than your `maxItems`, or `incrementalSince` may skip older jobs. Try removing freshness filters or broadening keywords.

#### How do I find location IDs?

Use APEC.fr manually, apply a location filter, then copy the search URL. The `lieux` URL parameter contains the APEC location ID.

#### Why are contract fields numeric?

APEC exposes many filters as nomenclature IDs. Numeric IDs are preserved so users can join them to their own mapping tables or reuse exact filters from APEC URLs.

### Related scrapers

Other Automation Lab actors can complement this workflow:

- LinkedIn job and company scrapers for broader hiring intelligence.
- Company/contact enrichment actors for recruiter lead qualification.
- Website contact finders for turning hiring companies into outreach lists.

### Changelog

Initial version extracts APEC search results and optional public detail records.

### Support

If a run fails or a field disappears, open an issue with the run ID and input used. Include whether the issue occurs with `fetchDetails` enabled or disabled.

### Field stability

The actor is designed to keep output field names stable. New fields may be added, but existing field names should remain compatible after publication.

### Performance

HTTP extraction is lightweight and normally fits in 256 MB memory. Detail fetching adds one request per saved job, so listing-only runs are faster than detail-rich runs.

### Recommended first run

Use this small input:

```json
{
  "keywords": ["data"],
  "locations": ["75"],
  "maxItems": 25,
  "fetchDetails": true
}
```

### Production run example

For a recurring lead-monitoring workflow:

```json
{
  "keywords": ["directeur data", "chief data officer", "data engineer"],
  "locations": ["75", "92"],
  "maxItems": 500,
  "fetchDetails": true,
  "incrementalSince": "2026-01-01T00:00:00Z"
}
```

# Actor input Schema

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

APEC.fr search result URLs to scrape. Paste URLs such as https://www.apec.fr/candidat/recherche-emploi.html/emploi?motsCles=data\&lieux=75. If provided, URL criteria are used first.

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

Search terms to query when start URLs are not supplied. Examples: data, directeur financier, product manager.

## `locations` (type: `array`):

APEC location codes from the lieux URL parameter, for example 75 for Paris. Leave empty for all France.

## `maxItems` (type: `integer`):

Maximum number of APEC job offers to save.

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

Fetch the public APEC detail API for full job description, profile, company text, skills, and recruiter name. Turn off for faster listing-only monitoring.

## `incrementalSince` (type: `string`):

Optional ISO date/time. Jobs older than this publication date are skipped, useful for recurring monitoring.

## `contractTypeIds` (type: `array`):

Optional raw APEC nomenclature IDs for contract filters (from the typesContrat URL parameter).

## `experienceLevelIds` (type: `array`):

Optional raw APEC nomenclature IDs for experience filters.

## `sectorIds` (type: `array`):

Optional raw APEC sector/activity IDs.

## `teleworkTypeIds` (type: `array`):

Optional raw APEC telework IDs.

## `minSalaryKeur` (type: `integer`):

Optional minimum salary filter in thousands of euros when supported by APEC search.

## `maxSalaryKeur` (type: `integer`):

Optional maximum salary filter in thousands of euros when supported by APEC search.

## `postedSince` (type: `string`):

Optional raw APEC datePublication filter value from a search URL. Use incrementalSince for normal recurring monitoring.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.apec.fr/candidat/recherche-emploi.html/emploi?motsCles=data&lieux=75"
    }
  ],
  "keywords": [
    "data"
  ],
  "locations": [
    "75"
  ],
  "maxItems": 20,
  "fetchDetails": true,
  "incrementalSince": "2026-01-01T00:00:00Z"
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.apec.fr/candidat/recherche-emploi.html/emploi?motsCles=data&lieux=75"
        }
    ],
    "keywords": [
        "data"
    ],
    "locations": [
        "75"
    ],
    "maxItems": 20,
    "fetchDetails": true,
    "incrementalSince": "2026-01-01T00:00:00Z"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/apec-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 = {
    "startUrls": [{ "url": "https://www.apec.fr/candidat/recherche-emploi.html/emploi?motsCles=data&lieux=75" }],
    "keywords": ["data"],
    "locations": ["75"],
    "maxItems": 20,
    "fetchDetails": True,
    "incrementalSince": "2026-01-01T00:00:00Z",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/apec-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 '{
  "startUrls": [
    {
      "url": "https://www.apec.fr/candidat/recherche-emploi.html/emploi?motsCles=data&lieux=75"
    }
  ],
  "keywords": [
    "data"
  ],
  "locations": [
    "75"
  ],
  "maxItems": 20,
  "fetchDetails": true,
  "incrementalSince": "2026-01-01T00:00:00Z"
}' |
apify call automation-lab/apec-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "APEC Jobs Scraper",
        "description": "Scrape APEC.fr executive jobs by keyword, location, salary, contract type, and freshness with descriptions, skills, and apply URLs.",
        "version": "0.1",
        "x-build-id": "ZGcl7dafpk6ztREe0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~apec-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-apec-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/automation-lab~apec-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-apec-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/automation-lab~apec-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-apec-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": {
                    "startUrls": {
                        "title": "APEC search URLs",
                        "type": "array",
                        "description": "APEC.fr search result URLs to scrape. Paste URLs such as https://www.apec.fr/candidat/recherche-emploi.html/emploi?motsCles=data&lieux=75. If provided, URL criteria are used first.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Search terms to query when start URLs are not supplied. Examples: data, directeur financier, product manager.",
                        "default": [
                            "data"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Location / department IDs",
                        "type": "array",
                        "description": "APEC location codes from the lieux URL parameter, for example 75 for Paris. Leave empty for all France.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of APEC job offers to save.",
                        "default": 20
                    },
                    "fetchDetails": {
                        "title": "Fetch job detail pages",
                        "type": "boolean",
                        "description": "Fetch the public APEC detail API for full job description, profile, company text, skills, and recruiter name. Turn off for faster listing-only monitoring.",
                        "default": true
                    },
                    "incrementalSince": {
                        "title": "Only jobs published after",
                        "type": "string",
                        "description": "Optional ISO date/time. Jobs older than this publication date are skipped, useful for recurring monitoring."
                    },
                    "contractTypeIds": {
                        "title": "Contract type IDs",
                        "type": "array",
                        "description": "Optional raw APEC nomenclature IDs for contract filters (from the typesContrat URL parameter).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "experienceLevelIds": {
                        "title": "Experience level IDs",
                        "type": "array",
                        "description": "Optional raw APEC nomenclature IDs for experience filters.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sectorIds": {
                        "title": "Sector IDs",
                        "type": "array",
                        "description": "Optional raw APEC sector/activity IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "teleworkTypeIds": {
                        "title": "Remote / telework type IDs",
                        "type": "array",
                        "description": "Optional raw APEC telework IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minSalaryKeur": {
                        "title": "Minimum salary (k€)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Optional minimum salary filter in thousands of euros when supported by APEC search."
                    },
                    "maxSalaryKeur": {
                        "title": "Maximum salary (k€)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Optional maximum salary filter in thousands of euros when supported by APEC search."
                    },
                    "postedSince": {
                        "title": "APEC publication filter",
                        "type": "string",
                        "description": "Optional raw APEC datePublication filter value from a search URL. Use incrementalSince for normal recurring monitoring."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```