# Airbnb Careers Scraper (`automation-lab/airbnb-careers-scraper`) Actor

Extract Airbnb careers jobs, locations, departments, workplace type, role text, and apply URLs. Export to JSON/CSV, schedule monitoring, and track hiring signals.

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

## Airbnb Careers Scraper

Extract public Airbnb job listings and job-detail pages from careers.airbnb.com.

Use this actor to monitor Airbnb hiring signals, collect current open roles, and feed recruiting, market-intelligence, sales, and workforce-analysis workflows.

---

### What does Airbnb Careers Scraper do?

Airbnb Careers Scraper collects structured job data from the public Airbnb careers site.

It starts from the Airbnb positions page or a specific Airbnb job URL.

It discovers job cards from listing pages.

It can follow pagination.

It can open job detail pages.

It saves each role as a clean dataset item.

It includes fields such as title, job ID, department, location, workplace type, role text, apply URL, and scrape timestamp.

No Airbnb account is required.

No login cookies are required.

No browser automation is required for the current public pages.

### Who is it for?

#### Recruiting and talent teams

Recruiters use it to watch which Airbnb teams are actively hiring, which locations are opening roles, and which job families are gaining headcount.

Talent sourcers use it to build target lists by department, location, or keyword, then route the exported roles into sourcing or talent-mapping workflows.

Job seekers use it to export Airbnb openings into their own tracking sheets and monitor changes without manually revisiting the careers site.

#### Sales and growth teams

Sales teams use hiring activity as a signal for growth, expansion, new budgets, or organizational change inside a strategic account.

Partnership teams use the data to understand which Airbnb functions may need services, vendors, or tooling based on current hiring patterns.

#### Market research and competitive intelligence teams

Market researchers use it to understand Airbnb workforce priorities by department, role type, and geography.

Competitive-intelligence teams use it to track new roles over time and compare hiring direction against other travel, marketplace, or hospitality companies.

Travel analysts use it to connect hiring signals with market strategy, product investment, compliance focus, and regional expansion.

#### Founders, operators, and analysts

Founders use it to study team-building patterns at a major travel platform.

Operators and workforce analysts use it to feed dashboards, scheduled monitors, and internal reports with repeatable public careers data.

### Why use this actor?

✅ It targets Airbnb's public careers pages directly.

✅ It returns structured records instead of raw HTML.

✅ It supports listing and detail URLs.

✅ It includes optional filters for department, location, workplace type, and keyword.

✅ It can extract job body text for downstream analysis.

✅ It works well in scheduled monitoring workflows.

✅ It is lightweight because it uses HTTP extraction.

### Data fields

| Field | Description |
| --- | --- |
| `jobId` | Numeric Airbnb/Greenhouse job identifier when available |
| `title` | Job title |
| `jobUrl` | Airbnb careers detail page URL |
| `department` | Department or function shown on the listing page |
| `team` | Team value, usually the same as department |
| `locations` | List of visible locations |
| `workplaceType` | Work-flexibility label such as hybrid or work-anywhere |
| `listingPage` | Listing page where the role was discovered |
| `listingOrder` | Position of the role on the listing page |
| `descriptionText` | Clean role overview text from the detail page |
| `responsibilities` | Extracted lines that appear to describe responsibilities |
| `qualifications` | Extracted lines that appear to describe qualifications or skills |
| `applyUrl` | Public Greenhouse apply/job URL inferred from the job ID |
| `postedDate` | Nullable placeholder if Airbnb exposes a posted date |
| `updatedDate` | Nullable placeholder if Airbnb exposes an updated date |
| `scrapedAt` | ISO timestamp when the item was saved |

### How much does it cost to scrape Airbnb careers jobs?

This actor uses pay-per-event pricing.

A small start fee of `$0.005` is charged once per run.

A per-job event is charged for each saved job record.

Current per-job tier prices:

| Tier | Price per saved job |
| --- | ---: |
| FREE | `$0.000095` |
| BRONZE | `$0.000083` |
| SILVER | `$0.000065` |
| GOLD | `$0.00005` |
| PLATINUM | `$0.000033` |
| DIAMOND | `$0.000023` |

For a typical HTTP run, compute costs are low.

The final platform pricing is visible on the Apify actor page before you start a run.

Use a low `maxItems` value for your first test.

Then increase `maxItems` for scheduled monitoring or full exports.

### How to use Airbnb Careers Scraper

1. Open the actor on Apify.

2. Keep the default start URL: `https://careers.airbnb.com/positions/`.

3. Set `maxItems` to the number of jobs you want.

4. Add an optional department, location, workplace type, or search term.

5. Keep `includeDetails` enabled if you need role body text.

6. Start the run.

7. Export the dataset as JSON, CSV, Excel, XML, or through the API.

### Input options

#### Start URLs

Use the main Airbnb careers positions page to discover open roles.

You can also provide a direct job detail URL.

Examples:

- `https://careers.airbnb.com/positions/`

- `https://careers.airbnb.com/positions/7732569/`

#### Maximum jobs

`maxItems` controls how many job records are saved.

The default is intentionally small for a cheap first run.

Set a larger value to export more open roles.

#### Search term

Use `searchTerm` for broad keyword filtering.

Examples:

- `data`

- `engineering`

- `marketing`

- `remote`

#### Departments

Use `departments` to keep roles from specific Airbnb functions.

Examples:

- `Engineering`

- `Data Science`

- `Account Management`

#### Locations

Use `locations` to keep roles for specific locations.

Examples:

- `United States`

- `Paris`

- `Bangalore`

- `Remote`

#### Workplace types

Use `workplaceTypes` for Airbnb's public flexibility labels.

Examples:

- `Live and Work Anywhere`

- `Hybrid - Be close to an office`

#### Include details

When `includeDetails` is true, the actor opens each job page.

This adds role body text, responsibility snippets, qualification snippets, and apply URL.

Disable it when you only need a fast list of titles and locations.

### Example input

```json
{
  "startUrls": [
    { "url": "https://careers.airbnb.com/positions/" }
  ],
  "maxItems": 25,
  "searchTerm": "data",
  "includeDetails": true
}
````

### Example output

```json
{
  "jobId": "7732569",
  "title": "(Contract) Senior Data Scientist, Platform Inference - MarTech DS Measurement",
  "jobUrl": "https://careers.airbnb.com/positions/7732569/",
  "department": "Data Science",
  "team": "Data Science",
  "locations": ["United States"],
  "workplaceType": "Live and Work Anywhere",
  "listingPage": "https://careers.airbnb.com/positions/",
  "listingOrder": 1,
  "descriptionText": "Airbnb was born in 2007...",
  "responsibilities": "...",
  "qualifications": "...",
  "applyUrl": "https://job-boards.greenhouse.io/airbnb/jobs/7732569",
  "postedDate": null,
  "updatedDate": null,
  "scrapedAt": "2026-06-07T00:00:00.000Z"
}
```

### Tips for best results

Start with the default URL.

Use `maxItems: 10` for a quick test.

Use `includeDetails: false` for faster listing-only exports.

Use `includeDetails: true` for role-analysis workflows.

Use filters only when you need a subset.

Leave filters blank to export all visible roles up to your limit.

Schedule the actor daily or weekly to monitor changes.

Store previous datasets if you want to compare hiring trends over time.

### Integrations

Send results to Google Sheets for recruiter review.

Send results to Airtable for talent-pipeline tracking.

Send results to a CRM to enrich company-growth signals.

Send results to a warehouse for longitudinal hiring analysis.

Trigger Slack alerts when new matching roles appear.

Connect with Apify webhooks for automated downstream processing.

Use dataset API endpoints for dashboards and BI tools.

### 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/airbnb-careers-scraper').call({
  startUrls: [{ url: 'https://careers.airbnb.com/positions/' }],
  maxItems: 25,
  includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/airbnb-careers-scraper').call(run_input={
    'startUrls': [{'url': 'https://careers.airbnb.com/positions/'}],
    'maxItems': 25,
    'includeDetails': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~airbnb-careers-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://careers.airbnb.com/positions/"}],"maxItems":25,"includeDetails":true}'
```

### MCP usage

Use this actor from MCP-compatible tools through Apify MCP.

Claude Code MCP add command:

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

Claude Code MCP URL:

`https://mcp.apify.com/?tools=automation-lab/airbnb-careers-scraper`

Claude Desktop MCP JSON configuration:

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

Claude Desktop MCP URL:

`https://mcp.apify.com/?tools=automation-lab/airbnb-careers-scraper`

Example prompts:

- "Scrape the latest Airbnb data science roles and summarize the locations."

- "Find Airbnb roles mentioning marketing measurement."

- "Export Airbnb engineering jobs and group them by workplace type."

### Scheduling workflows

Run the actor every day to detect new Airbnb roles.

Run it weekly to track broader hiring trends.

Compare each dataset with the previous run.

Alert only when a new job ID appears.

Filter by department to keep alerts focused.

### Common use cases

Monitor Airbnb hiring activity.

Track growth in specific departments.

Watch international expansion signals.

Build recruiter target lists.

Analyze skill requirements in job descriptions.

Compare workplace flexibility language over time.

Feed company-intelligence dashboards.

### Troubleshooting

#### Why did I get fewer jobs than `maxItems`?

The source may have fewer jobs matching your filters.

Try removing filters or increasing the number of listing pages by raising `maxItems`.

#### Why are `postedDate` and `updatedDate` null?

Airbnb's public careers HTML does not consistently expose those dates.

The fields are included for schema stability if the source starts exposing them later.

#### Why is the apply URL on Greenhouse?

Airbnb embeds a Greenhouse application form and exposes the public Greenhouse job ID.

The actor builds the corresponding public Greenhouse job URL from that ID.

### Data quality notes

Airbnb can change page markup without notice.

The actor is built for the current public WordPress/FacetWP careers pages.

It does not bypass login walls.

It does not scrape private applicant data.

It collects only publicly visible job information.

### Legality

This actor collects publicly available career-page information.

You are responsible for using the data lawfully.

Respect applicable laws, contracts, and platform terms.

Do not use the output for unlawful discrimination, spam, or prohibited profiling.

If in doubt, consult your legal counsel.

### Related scrapers

Explore related actors from Automation Lab:

- https://apify.com/automation-lab/airbnb-scraper

- https://apify.com/automation-lab/airbnb-reviews-scraper

- https://apify.com/automation-lab/google-maps-lead-finder

- https://apify.com/automation-lab/linkedin-jobs-scraper

### FAQ

#### Does this actor require an Airbnb login?

No. It uses public careers pages.

#### Does it use a browser?

No. It uses HTTP requests and HTML parsing for the current site.

#### Can I scrape one specific job?

Yes. Provide a direct Airbnb job detail URL in `startUrls`.

#### Can I filter by location?

Yes. Use the `locations` input array.

#### Can I filter by team?

Yes. Use the `departments` input array.

#### Can I export to CSV?

Yes. Apify datasets support CSV, JSON, Excel, XML, RSS, and API exports.

#### Can I run it on a schedule?

Yes. Use Apify schedules to run it daily, weekly, or monthly.

#### Can it find closed jobs?

No. It extracts jobs currently visible on Airbnb's public careers pages.

#### Can it scrape applicant information?

No. It only collects public job posting information.

#### What should I do if results look empty?

Check your filters first.

Then run with the default input and a small `maxItems` value.

If the default input returns no results, the source markup may have changed.

# Actor input Schema

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

Airbnb careers listing or job-detail URLs. The default positions page discovers current open roles.

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

Maximum number of Airbnb job records to save.

## `searchTerm` (type: `string`):

Only keep jobs whose title, department, location, workplace type, or detail text contains this term.

## `departments` (type: `array`):

Optional department/team filters such as Data Science, Engineering, or Account Management.

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

Optional location filters such as United States, Paris, or Remote.

## `workplaceTypes` (type: `array`):

Optional work-flexibility filters, for example Live and Work Anywhere or Hybrid - Be close to an office.

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

Fetch each job detail page to include role body text, inferred qualifications/responsibilities snippets, and Greenhouse apply URL.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://careers.airbnb.com/positions/"
    }
  ],
  "maxItems": 10,
  "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 = {
    "startUrls": [
        {
            "url": "https://careers.airbnb.com/positions/"
        }
    ],
    "maxItems": 10,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/airbnb-careers-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://careers.airbnb.com/positions/" }],
    "maxItems": 10,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/airbnb-careers-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://careers.airbnb.com/positions/"
    }
  ],
  "maxItems": 10,
  "includeDetails": true
}' |
apify call automation-lab/airbnb-careers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Careers Scraper",
        "description": "Extract Airbnb careers jobs, locations, departments, workplace type, role text, and apply URLs. Export to JSON/CSV, schedule monitoring, and track hiring signals.",
        "version": "0.1",
        "x-build-id": "87XFkMsaQtET022dF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~airbnb-careers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-airbnb-careers-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~airbnb-careers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-airbnb-careers-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~airbnb-careers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-airbnb-careers-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": "Start URLs",
                        "type": "array",
                        "description": "Airbnb careers listing or job-detail URLs. The default positions page discovers current open roles.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Airbnb job records to save.",
                        "default": 20
                    },
                    "searchTerm": {
                        "title": "Search term",
                        "type": "string",
                        "description": "Only keep jobs whose title, department, location, workplace type, or detail text contains this term."
                    },
                    "departments": {
                        "title": "Departments",
                        "type": "array",
                        "description": "Optional department/team filters such as Data Science, Engineering, or Account Management.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional location filters such as United States, Paris, or Remote.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "workplaceTypes": {
                        "title": "Workplace types",
                        "type": "array",
                        "description": "Optional work-flexibility filters, for example Live and Work Anywhere or Hybrid - Be close to an office.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDetails": {
                        "title": "Open job detail pages",
                        "type": "boolean",
                        "description": "Fetch each job detail page to include role body text, inferred qualifications/responsibilities snippets, and Greenhouse apply URL.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
