# Recruitee Jobs Scraper (`automation-lab/recruitee-jobs-scraper`) Actor

🏢 Export public jobs from one or many Recruitee career sites with locations, descriptions, salary, timestamps, and application links.

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

from $0.02 / 1,000 item extracteds

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Recruitee Jobs Scraper

Collect public job openings from any company career site hosted on Recruitee.

Provide company slugs or full career URLs and receive clean, structured job records ready for export, monitoring, analysis, or automation.

The Actor uses Recruitee's public career-site data surface directly. It does not require a login, browser, cookie, or company API key.

### What does Recruitee Jobs Scraper do?

Recruitee Jobs Scraper extracts live vacancies from one or many `company.recruitee.com` sites.

For each opening, it returns:

- company and source identifiers
- stable offer ID and GUID
- title and department
- employment and experience level
- primary and nested locations
- remote, hybrid, and on-site flags
- salary and weekly hours when published
- clean description and requirements text
- optional original HTML
- creation, publication, update, and closing timestamps
- career and direct application URLs

Results from repeated or duplicate inputs are deduplicated by company and offer ID.

### Who is it for?

#### Job-board operators

Feed current employer openings into niche job boards without manually checking every career page.

#### Recruiters and talent teams

Track hiring activity across target companies and discover newly opened roles.

#### Sales and market-intelligence teams

Use job creation, department, location, and seniority as company-growth signals.

#### Labor-market analysts

Build recurring datasets for location, role, salary, and employer trend analysis.

#### Data engineers

Export normalized Recruitee data into warehouses, spreadsheets, webhooks, and scheduled workflows.

### Why use this Actor?

- ⚡ **Fast HTTP extraction** — no browser startup overhead.
- 🔓 **No Recruitee credentials** — reads public career-site records only.
- 🏢 **Multi-company input** — synchronize several employers in one run.
- 🧹 **Normalized output** — consistent names and clean description text.
- 🔗 **Traceable records** — every result includes its source URL.
- 🛡️ **Partial-failure handling** — one invalid company does not erase successful results.
- 💾 **Export ready** — use JSON, CSV, Excel, XML, RSS, or API access from the Apify dataset.

### How to scrape Recruitee jobs

1. Open the Actor input page.
2. Add one or more company slugs, such as `skygeo`.
3. Alternatively, paste full URLs such as `https://skygeo.recruitee.com/`.
4. Set the maximum number of job records.
5. Choose whether to retain original description HTML.
6. Click **Start**.
7. Open the dataset to preview or download results.

The default input is deliberately small so a first run finishes quickly.

### Input

| Field | Type | Default | Description |
|---|---|---:|---|
| `companySlugs` | string[] | `['skygeo']` | Recruitee subdomains without `.recruitee.com` |
| `careerUrls` | string[] | `[]` | Full Recruitee career-site URLs |
| `maxItems` | integer | `100` | Maximum records across all companies |
| `includeDescriptionHtml` | boolean | `true` | Retain source HTML alongside clean text |

You may combine slugs and URLs in the same run.

Duplicate company sources are requested only once.

The maximum supported limit is 10,000 records per run.

#### Small input example

```json
{
  "companySlugs": ["skygeo"],
  "maxItems": 10,
  "includeDescriptionHtml": true
}
````

#### Multi-company example

```json
{
  "careerUrls": [
    "https://skygeo.recruitee.com/",
    "https://recruitee.recruitee.com/"
  ],
  "maxItems": 500,
  "includeDescriptionHtml": false
}
```

### Output data

Each dataset row represents one public Recruitee offer.

| Field | Description |
|---|---|
| `companySlug` | Recruitee subdomain used as source identifier |
| `companyName` | Employer name published with the offer |
| `offerId` | Stable Recruitee offer ID |
| `guid` | Recruitee short offer identifier |
| `slug` | URL-safe job slug |
| `title` | Job title |
| `department` | Hiring department |
| `employmentType` | Employment type code |
| `experienceLevel` | Experience-level code |
| `educationLevel` | Education-level code |
| `location` | Primary display location |
| `locations` | Structured list of all published locations |
| `remote` | Whether the offer is marked remote |
| `hybrid` | Whether the offer is marked hybrid |
| `onSite` | Whether the offer is marked on-site |
| `salary` | Published minimum, maximum, period, and currency |
| `descriptionText` | HTML-free job description |
| `descriptionHtml` | Original description HTML when enabled |
| `requirementsText` | HTML-free requirements |
| `tags` | Published offer tags |
| `createdAt` | Offer creation time |
| `updatedAt` | Last update time |
| `publishedAt` | Publication time |
| `closesAt` | Closing time when supplied |
| `careerUrl` | Public job page |
| `applyUrl` | Direct application page |
| `sourceUrl` | Recruitee API source |
| `scrapedAt` | Extraction timestamp |

### Output example

```json
{
  "companySlug": "skygeo",
  "companyName": "SkyGeo",
  "offerId": 123456,
  "title": "Senior Demand Generation Manager",
  "department": "Marketing",
  "location": "Delft, Netherlands",
  "remote": false,
  "hybrid": false,
  "countryCode": "NL",
  "careerUrl": "https://skygeo.recruitee.com/o/senior-demand-generation-manager",
  "sourceUrl": "https://skygeo.recruitee.com/api/offers/"
}
```

Fields that an employer does not publish are omitted rather than filled with misleading values.

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

This Actor uses pay-per-event pricing:

- a small one-time run start charge
- a per-job result charge
- automatic volume discounts for higher Apify plans

You pay for records produced, not for empty or invalid offers.

The exact current tier prices are shown on the Actor's Store page before each run.

Use a low `maxItems` value to estimate a workflow before scheduling large synchronizations.

### Deduplication and item limits

A job's unique key combines `companySlug` and `offerId`.

This prevents duplicate output when a company is supplied as both a slug and URL.

`maxItems` applies globally across all sources in their input order.

If the limit is reached during one company, later companies are not requested.

### Error handling

Malformed URLs are skipped with a warning.

A missing or unavailable company site is logged as a source error.

Other valid companies continue processing.

The Actor fails clearly when no valid source remains.

Requests have bounded timeouts to avoid runs hanging indefinitely.

### Scheduling a jobs monitor

Use an Apify schedule to run the Actor hourly, daily, or weekly.

For incremental workflows:

1. schedule the same stable company list
2. store `companySlug + offerId` in your destination
3. compare `createdAt` and `updatedAt`
4. alert on unseen IDs or changed timestamps
5. mark IDs absent from later runs according to your own closure policy

Apify webhooks can notify another service after every successful run.

### Integrations

#### Google Sheets

Use the Google Sheets integration to maintain a hiring tracker for recruiters or sales teams.

#### Webhooks

Send finished-run events to Make, Zapier, n8n, or an internal API.

#### Data warehouses

Read dataset records through the API and load them into BigQuery, Snowflake, or PostgreSQL.

#### Job boards

Map stable IDs and application URLs into a recurring job-feed import.

#### Slack alerts

Trigger a message when a monitored employer posts a new role in a target department.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/recruitee-jobs-scraper').call({
  companySlugs: ['skygeo'],
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/recruitee-jobs-scraper').call(run_input={
    'companySlugs': ['skygeo'],
    'maxItems': 100,
})
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~recruitee-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companySlugs":["skygeo"],"maxItems":100}'
```

Fetch results from the run's `defaultDatasetId` after it succeeds.

### Use with Apify MCP

Connect the Actor to AI assistants through Apify MCP. In Claude Code, run:

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

For Claude Desktop, Cursor, or VS Code, add this HTTP server to the client's MCP JSON configuration:

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

Restart the client after saving the configuration. The first Actor call may ask you to sign in to Apify and authorize access.

Useful prompts include:

- “Export all current SkyGeo jobs into a table.”
- “Which monitored companies are hiring marketing roles?”
- “Compare remote openings across these Recruitee employers.”
- “Find newly published engineering jobs and summarize requirements.”

### Tips for reliable results

- Copy the hostname directly from the employer's public career page.
- Use only the subdomain as `companySlugs`.
- Prefer full URLs when users paste sources from spreadsheets.
- Keep HTML enabled when preserving formatting matters.
- Disable HTML to reduce output size for analytics.
- Schedule at a reasonable cadence; public vacancies rarely need minute-level polling.
- Use timestamps and stable IDs rather than job titles for change detection.

### Limitations

The Actor extracts only public offers exposed by a Recruitee-hosted career site.

It cannot access draft, archived, private, or account-only vacancies.

Employers control which fields they publish, so salary and hours may be absent.

Recruitee can change its public response structure; the Actor normalizes currently observed fields.

The Actor does not submit applications or collect applicant information.

### Legality

This Actor reads publicly available career-site information without authentication.

You are responsible for your purpose, storage, redistribution, and compliance with applicable terms and laws.

Avoid using job data for unlawful discrimination, spam, or decisions that require additional legal safeguards.

Do not collect or infer applicant personal data with this Actor.

When in doubt, consult qualified legal counsel for your jurisdiction and use case.

### Troubleshooting

#### Why did one company return no records?

Check that the hostname ends in `.recruitee.com` and that its public career site currently lists vacancies.

#### Why are salary fields missing?

Salary appears only when the employer publishes it in the offer.

#### Why is the run successful after a source error?

Multi-company runs intentionally preserve successful sources. Review logs to identify skipped companies.

#### Why did output stop before every company?

The global `maxItems` limit was reached. Increase it or split sources across runs.

#### How do I remove HTML?

Set `includeDescriptionHtml` to `false`; clean text remains available.

### FAQ

#### Does it require a Recruitee account?

No. It reads anonymous public career-site data.

#### Does it use a browser or proxy?

No browser is required for the standard public endpoint, keeping runs fast and lightweight.

#### Can I monitor hundreds of companies?

Yes, within the 10,000-item run limit. For large portfolios, batch sources and schedule runs sensibly.

#### Can I export CSV or Excel?

Yes. Open the Apify dataset and select the desired export format.

#### Are results deduplicated across runs?

Deduplication occurs within each run. Use the stable company and offer ID pair in your destination for cross-run history.

### Related scrapers

Build a broader ATS monitoring workflow with other Automation Lab actors:

- [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper)
- [Personio Jobs Scraper](https://apify.com/automation-lab/personio-jobs-scraper)
- [Teamtailor Jobs Scraper](https://apify.com/automation-lab/teamtailor-jobs-scraper)
- [Ashby Jobs Scraper](https://apify.com/automation-lab/ashby-jobs-scraper)

Each source-specific actor preserves the fields and identifiers exposed by that ATS.

### Support

If a valid public Recruitee company returns unexpected data, open an issue from the Actor page.

Include the public career URL, input, run ID, and a short description of the expected result.

Do not include applicant data, credentials, or private company information.

# Actor input Schema

## `companySlugs` (type: `array`):

Subdomains from company.recruitee.com.

## `careerUrls` (type: `array`):

Full URLs such as https://company.recruitee.com/.

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

Maximum job records across all companies.

## `includeDescriptionHtml` (type: `boolean`):

Keep original HTML alongside normalized plain text.

## Actor input object example

```json
{
  "companySlugs": [
    "skygeo"
  ],
  "careerUrls": [],
  "maxItems": 10,
  "includeDescriptionHtml": 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 = {
    "companySlugs": [
        "skygeo"
    ],
    "careerUrls": [],
    "maxItems": 10,
    "includeDescriptionHtml": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/recruitee-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 = {
    "companySlugs": ["skygeo"],
    "careerUrls": [],
    "maxItems": 10,
    "includeDescriptionHtml": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/recruitee-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 '{
  "companySlugs": [
    "skygeo"
  ],
  "careerUrls": [],
  "maxItems": 10,
  "includeDescriptionHtml": true
}' |
apify call automation-lab/recruitee-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Recruitee Jobs Scraper",
        "description": "🏢 Export public jobs from one or many Recruitee career sites with locations, descriptions, salary, timestamps, and application links.",
        "version": "0.1",
        "x-build-id": "dRtweSyXF9MqVyigp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~recruitee-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-recruitee-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~recruitee-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-recruitee-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~recruitee-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-recruitee-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": {
                    "companySlugs": {
                        "title": "Company slugs",
                        "type": "array",
                        "description": "Subdomains from company.recruitee.com.",
                        "default": [
                            "skygeo"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "careerUrls": {
                        "title": "Career site URLs",
                        "type": "array",
                        "description": "Full URLs such as https://company.recruitee.com/.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum job records across all companies.",
                        "default": 100
                    },
                    "includeDescriptionHtml": {
                        "title": "Include description HTML",
                        "type": "boolean",
                        "description": "Keep original HTML alongside normalized plain text.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```