# Jobbird Jobs Scraper (`automation-lab/jobbird-jobs-scraper`) Actor

Scrape Dutch Jobbird vacancies by keyword, city, radius, or search URL. Export employers, salary, hours, descriptions, dates, and apply links.

- **URL**: https://apify.com/automation-lab/jobbird-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

## Jobbird Jobs Scraper

Extract public Dutch job vacancies from Jobbird.com.

### What does Jobbird Jobs Scraper do?

Jobbird Jobs Scraper collects vacancy data from public Jobbird search and detail pages.

It helps you turn Jobbird job-search pages into structured datasets.

The actor can search by keyword.

It can search by Dutch city or region.

It can use direct Jobbird search URLs.

It can open vacancy detail pages.

It extracts structured Schema.org JobPosting data when available.

It saves each vacancy as one dataset row.

### Who is it for?

#### Recruiting and staffing teams

Recruiters can monitor fresh Dutch vacancies for roles they place often.

Staffing agencies can track demand by city, skill, and employer category.

Sourcers can find companies that are actively hiring before opening a sales conversation.

#### Sales and lead-generation teams

Lead-generation teams can find companies and recruiters posting jobs right now.

Sales teams can build hiring-intent lists for HR software, payroll, training, benefits, recruitment, and staffing offers.

Agency owners can export company names, titles, locations, and apply links for enrichment in a CRM.

#### Labor-market and data teams

Labor-market analysts can compare hiring trends by role, city, salary range, or date posted.

Job-board researchers can audit supply in specific roles without manually copying search results.

HR technology teams can enrich internal job intelligence workflows with repeatable Jobbird data.

### Why use this actor?

Jobbird is a visible Dutch job board.

Manual searching is slow when you need repeatable data.

This actor gives you clean fields for analysis.

It supports repeat runs for monitoring.

It uses HTTP extraction instead of a browser for lower overhead.

It follows public pages only.

It preserves source URLs for verification.

### What data can you extract?

| Field | Description |
| --- | --- |
| `jobId` | Jobbird vacancy identifier when available |
| `title` | Vacancy title |
| `company` | Hiring company or recruiter |
| `location` | Job location |
| `addressRegion` | Region from structured data |
| `addressCountry` | Country code |
| `salaryMin` | Minimum salary when structured data provides it |
| `salaryMax` | Maximum salary when structured data provides it |
| `salaryCurrency` | Salary currency |
| `salaryText` | Salary text from the listing card |
| `workHours` | Hours per week or full-time hints |
| `employmentType` | Employment type values |
| `educationRequirements` | Education requirements when present |
| `experienceRequirements` | Experience requirements when present |
| `directApply` | Whether the posting marks direct apply |
| `datePosted` | Posting date |
| `validThrough` | Expiration date when present |
| `descriptionHtml` | Original vacancy description HTML |
| `descriptionText` | Plain-text vacancy description |
| `applyUrl` | Apply or outbound URL |
| `sourceUrl` | Jobbird vacancy URL |
| `searchUrl` | Search URL where the vacancy was found |
| `scrapedAt` | Extraction timestamp |

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

This actor uses pay-per-event pricing.

A small start charge applies to each run.

A per-vacancy charge applies to each saved vacancy.

Current private-build pricing is approximately:

| Event | Price |
| --- | ---: |
| Run started | $0.005 per run |
| Vacancy extracted, FREE tier | $0.00010715 per vacancy |
| Vacancy extracted, BRONZE tier | $0.000093173 per vacancy |
| Vacancy extracted, SILVER tier | $0.000072675 per vacancy |
| Vacancy extracted, GOLD tier | $0.000055904 per vacancy |
| Vacancy extracted, PLATINUM tier | $0.000037269 per vacancy |
| Vacancy extracted, DIAMOND tier | $0.000026088 per vacancy |

Example cost estimates on the FREE tier:

| Run size | Estimated actor charge |
| --- | ---: |
| 25 vacancies | about $0.0077 |
| 100 vacancies | about $0.0157 |
| 500 vacancies | about $0.0586 |
| 1,000 vacancies | about $0.1122 |

These examples include the start event and per-vacancy event only. Platform usage, proxy usage, and your Apify plan terms may also apply.

The Apify Free plan includes monthly platform credits. With this actor's current FREE-tier event price, those credits can cover many small tests, but the exact number depends on your other Apify usage and platform resource costs. Start with `maxItems` between 25 and 100, check the run's charged events, then increase the limit after confirming your search terms.

The Apify run console shows charged events and usage after each run.

### How to scrape Jobbird vacancies

1. Open the actor on Apify.

2. Enter one or more search terms, such as `developer`, `chauffeur`, or `verpleegkundige`.

3. Optionally enter Dutch locations, such as `Amsterdam`, `Rotterdam`, `Utrecht`, or `Eindhoven`.

4. Choose a radius in kilometers when you use locations.

5. Choose `date` for newest-first monitoring or `relevance` for Jobbird's default ranking.

6. Set `maxItems` to the maximum number of vacancies you want to save.

7. Keep `includeDetails` enabled when you need descriptions, salary fields, structured dates, and apply URLs.

8. Start the run and watch the log for the number of unique vacancies collected.

9. Download the dataset as JSON, CSV, Excel, XML, or via API.

10. Save the same input as an Apify task or schedule if you want recurring monitoring.

### Input options

#### `searchTerms`

Keywords to search on Jobbird.

Examples include `developer`, `verpleegkundige`, `chauffeur`, `finance`, and `marketing`.

#### `locations`

Optional city or region names.

Examples include `Amsterdam`, `Rotterdam`, `Utrecht`, and `Eindhoven`.

Leave empty to search across all available results for the keyword.

#### `radiusKm`

Search radius around the location.

Common values are 5, 10, 15, 30, 50, and 100.

#### `sortBy`

Use `date` for newest first.

Use `relevance` for Jobbird's relevance ordering.

#### `startUrls`

Paste direct Jobbird search URLs if you already built the search on Jobbird.

When `startUrls` is provided, the actor uses those URLs instead of `searchTerms` and `locations`.

#### `maxItems`

Maximum unique vacancies to save across all searches.

#### `includeDetails`

Enable detail-page fetching for descriptions, structured salary, employer, location, and apply URL.

Disable it for faster lightweight listing extraction.

### Example input

```json
{
  "searchTerms": ["developer", "data analyst"],
  "locations": ["Amsterdam", "Rotterdam"],
  "radiusKm": 30,
  "sortBy": "date",
  "maxItems": 50,
  "includeDetails": true
}
````

### Example output

```json
{
  "jobId": "25404797",
  "title": "Senior Java Developer",
  "company": "GeekSoft Consulting",
  "location": "AMSTERDAM",
  "salaryMin": 90000,
  "salaryMax": 130000,
  "salaryCurrency": "EUR",
  "workHours": "32 - 40",
  "employmentType": ["FULL_TIME"],
  "datePosted": "2026-07-10T06:18:58+02:00",
  "directApply": true,
  "sourceUrl": "https://www.jobbird.com/nl/vacature/25404797-senior-java-developer",
  "scrapedAt": "2026-07-10T05:20:41.336Z"
}
```

### Tips for better results

Use specific job titles for cleaner datasets.

Use multiple cities when monitoring regional demand.

Keep detail extraction enabled when you need descriptions or apply URLs.

Use direct Jobbird URLs for advanced searches you built on the website.

Use `maxItems` to control spend.

Run the actor on a schedule to monitor new vacancies.

Export CSV for spreadsheets.

Export JSON for data pipelines.

### Common workflows

Track new software developer jobs in Amsterdam.

Monitor healthcare vacancies around Utrecht.

Find logistics employers hiring drivers.

Build a recruiter prospecting list from new vacancies.

Compare salary ranges by role.

Collect job descriptions for labor-market text analysis.

Watch demand for specific skills over time.

### Integrations

Send results to Google Sheets using Apify integrations.

Connect the dataset to Make or Zapier.

Use webhooks to trigger downstream enrichment.

Store historical runs for trend analysis.

Load results into a CRM as hiring-intent leads.

Send new vacancies to Slack or email alerts.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/jobbird-jobs-scraper').call({
  searchTerms: ['developer'],
  locations: ['Amsterdam'],
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/jobbird-jobs-scraper').call(run_input={
    'searchTerms': ['developer'],
    'locations': ['Amsterdam'],
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~jobbird-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["developer"],"locations":["Amsterdam"],"maxItems":25}'
```

### MCP usage

Use the Apify MCP server with this actor in Claude tools.

MCP URL:

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

Claude Code setup:

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

Claude Desktop JSON config:

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

Example prompts:

- Scrape 50 developer vacancies from Jobbird around Amsterdam.
- Find recent nursing jobs around Utrecht and summarize employers.
- Monitor new chauffeur vacancies and return company names and apply links.

### Scheduling

You can schedule this actor daily or weekly.

Use a fixed set of search terms.

Keep `sortBy` set to `date` for monitoring.

Deduplicate downstream by `jobId` or `sourceUrl`.

### Data quality notes

Jobbird pages may contain sponsored or partner vacancies.

Some jobs provide complete salary ranges.

Some jobs provide only salary text.

Some jobs omit salary.

Apply URLs may point to Jobbird redirects or external employer systems.

Descriptions are extracted from public structured data when available.

### Limitations

The actor scrapes public Jobbird pages only.

It does not log into Jobbird.

It does not apply to jobs.

It does not bypass private employer systems.

Result availability depends on Jobbird's current public search results.

Search pages may return related vacancies when exact keyword matches are sparse.

### FAQ

#### Can I use direct Jobbird search URLs?

Yes. Add Jobbird search URLs to `startUrls` and the actor will use them instead of keyword/location fields.

#### Can I run this actor every day?

Yes. Use Apify schedules and keep `sortBy` set to `date` for monitoring new vacancies.

### Troubleshooting

#### Why did I get fewer results than requested?

Your selected searches may expose fewer unique vacancies in the currently visible public results.

Try more search terms or more locations.

#### Why is salary missing?

Some Jobbird postings do not publish structured salary information.

Use `salaryText`, `salaryMin`, and `salaryMax` together for analysis.

#### Why is the apply URL a redirect?

Jobbird often routes applications through tracking or partner redirects.

The actor preserves the public apply URL provided by the page.

### Legality

This actor extracts publicly available job-posting information.

You are responsible for using the data lawfully.

Respect Jobbird's terms, privacy rules, and applicable regulations.

Do not use the actor to collect private account data.

Do not overload the target website.

### Related scrapers

Explore other Automation Lab job and lead-generation actors on Apify:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/linkedin-company-url-finder
- https://apify.com/automation-lab/website-contact-finder

### Support

If a run fails, check the run log first.

Confirm your input uses public Jobbird search URLs or normal keywords.

Lower `maxItems` for a quick diagnostic run.

Share the run ID with support if you need help.

### Changelog

See the actor changelog for release notes.

### Version

Initial private QA build: 0.1.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search on Jobbird, such as developer, verpleegkundige, chauffeur, finance, or marketing.

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

Optional Dutch city or region names. Leave empty to search all Netherlands results for each keyword.

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

Search radius around each location. Jobbird commonly supports 5, 10, 15, 30, 50, and 100 km.

## `sortBy` (type: `string`):

Use date for newest vacancies first or relevance for Jobbird's default relevance ranking.

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

Optional direct Jobbird search result URLs. If provided, the actor uses these instead of search terms and locations.

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

Maximum number of unique vacancies to save across all searches.

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

Fetch each public vacancy page to extract structured JobPosting data, descriptions, salary, employer, location, and apply URLs.

## Actor input object example

```json
{
  "searchTerms": [
    "developer",
    "data analyst"
  ],
  "locations": [
    "Amsterdam",
    "Rotterdam"
  ],
  "radiusKm": 30,
  "sortBy": "date",
  "startUrls": [
    {
      "url": "https://www.jobbird.com/nl/vacature?s=developer&rad=30&ot=date"
    }
  ],
  "maxItems": 20,
  "includeDetails": true
}
```

# 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": [
        "developer",
        "data analyst"
    ],
    "locations": [
        "Amsterdam",
        "Rotterdam"
    ],
    "radiusKm": 30,
    "sortBy": "date",
    "startUrls": [
        {
            "url": "https://www.jobbird.com/nl/vacature?s=developer&rad=30&ot=date"
        }
    ],
    "maxItems": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/jobbird-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 = {
    "searchTerms": [
        "developer",
        "data analyst",
    ],
    "locations": [
        "Amsterdam",
        "Rotterdam",
    ],
    "radiusKm": 30,
    "sortBy": "date",
    "startUrls": [{ "url": "https://www.jobbird.com/nl/vacature?s=developer&rad=30&ot=date" }],
    "maxItems": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/jobbird-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 '{
  "searchTerms": [
    "developer",
    "data analyst"
  ],
  "locations": [
    "Amsterdam",
    "Rotterdam"
  ],
  "radiusKm": 30,
  "sortBy": "date",
  "startUrls": [
    {
      "url": "https://www.jobbird.com/nl/vacature?s=developer&rad=30&ot=date"
    }
  ],
  "maxItems": 20,
  "includeDetails": true
}' |
apify call automation-lab/jobbird-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobbird Jobs Scraper",
        "description": "Scrape Dutch Jobbird vacancies by keyword, city, radius, or search URL. Export employers, salary, hours, descriptions, dates, and apply links.",
        "version": "0.1",
        "x-build-id": "uv29FCQ2v7wnjtuiW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~jobbird-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-jobbird-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~jobbird-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-jobbird-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~jobbird-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-jobbird-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": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search on Jobbird, such as developer, verpleegkundige, chauffeur, finance, or marketing.",
                        "default": [
                            "developer"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional Dutch city or region names. Leave empty to search all Netherlands results for each keyword.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "radiusKm": {
                        "title": "Radius in kilometers",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Search radius around each location. Jobbird commonly supports 5, 10, 15, 30, 50, and 100 km.",
                        "default": 30
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "date",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Use date for newest vacancies first or relevance for Jobbird's default relevance ranking.",
                        "default": "date"
                    },
                    "startUrls": {
                        "title": "Jobbird search URLs",
                        "type": "array",
                        "description": "Optional direct Jobbird search result URLs. If provided, the actor uses these instead of search terms and locations.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum vacancies",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of unique vacancies to save across all searches.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Open vacancy detail pages",
                        "type": "boolean",
                        "description": "Fetch each public vacancy page to extract structured JobPosting data, descriptions, salary, employer, location, and apply URLs.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
