# Teamtailor Jobs Scraper (FreshActors) (`freshactors/teamtailor-jobs-scraper`) Actor

Reliable, always-fresh job postings from any Teamtailor career site. Public JSON feed, no login — full descriptions in a single call. Monitored daily. By FreshActors.

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

## Pricing

from $20.00 / 1,000 company jobs fetcheds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Teamtailor Jobs Scraper — Every Career Site as Clean JSON (No API Key)

Scrape **Teamtailor career-site job postings** from any company's public board into clean, structured JSON — title, full description, locations, country, posting date, and apply URL. No account, no login, no API key. Point it at a list of Teamtailor companies (or career-site URLs) and get a normalized jobs feed back.

![Teamtailor Jobs Scraper — normalized job postings with full descriptions](https://raw.githubusercontent.com/Freshactors/freshactors-assets/main/teamtailor-screenshot.png)

> ✅ **Last verified working: 2026-06-10.** Monitored by an automated daily canary. When Teamtailor changes its public feed, we patch fast and log it in the changelog below — so your hiring-data pipeline doesn't silently break.

---

### Why this Teamtailor scraper

Teamtailor powers the career sites of thousands of companies — it's especially strong among **Nordic and European scale-ups** (think Polestar- and Oatly-class brands). Every career site serves a **public JSON feed** of its published jobs — no key, no login, no browser. Even better: **a single request returns the company's full published board, descriptions included** — verified on boards of 40+ roles, no pagination to manage. The catch is the usual one: the moment the response shape shifts, a naive scraper silently returns nothing. This actor is built to **stay working**:

- **One normalized schema** — the same stable job record as our [Greenhouse & Lever](https://apify.com/freshactors/greenhouse-lever-jobs-scraper), [Workable](https://apify.com/freshactors/workable-jobs-scraper), [SmartRecruiters](https://apify.com/freshactors/smartrecruiters-jobs-scraper), and [Recruitee](https://apify.com/freshactors/recruitee-jobs-scraper) scrapers, so Teamtailor companies slot into the exact same pipeline with no special-casing.
- **Full descriptions, in one call** — each posting's complete description comes back cleaned to plain text. No extra requests, so it's fast and cheap.
- **Custom domains supported** — many Teamtailor customers run their careers page on their own domain (e.g. `careers.example.com`). Paste the URL; it works the same.
- **Per-company isolation + retries** — a dead, renamed, or private board is skipped and logged; it never crashes the run. Transient errors retry with backoff.
- **Stable, versioned output** (`_schemaVersion`) + a **daily canary** — that "last verified working" date is real.

### What data you get

Each row is one normalized job posting. Fields Teamtailor's public feed doesn't provide come back as `null`, never missing, so your downstream schema stays predictable.

| Field | Type | Description |
|---|---|---|
| `_type` | string | Always `job`. |
| `_schemaVersion` | string | Output schema version. |
| `_source` | string | Always `teamtailor`. |
| `company` | string | Company identifier (the `{name}.teamtailor.com` subdomain, or the custom-domain host you passed). |
| `jobId` | string | Teamtailor posting ID. |
| `title` | string | Job title. |
| `department` | null | Not exposed in Teamtailor's public feed — always `null`. |
| `team` | null | Not exposed — always `null`. |
| `location` | string \| null | Primary location ("City, Region, CC"). |
| `allLocations` | string[] \| null | Every listed location (multi-location postings supported). |
| `workplaceType` | null | Not exposed in the feed — always `null`. |
| `commitment` | null | Not exposed in the feed — always `null`. |
| `country` | string \| null | 2-letter country code of the first location. |
| `url` | string | Public posting URL. |
| `applyUrl` | string | The posting page (applications happen there). |
| `postedAt` | string \| null | Publish date (ISO). |
| `updatedAt` | null | Not exposed in the feed — always `null`. |
| `descriptionText` | string \| null | Full description as clean text (when `includeDescription` is on). |
| `_scrapedAt` | string | ISO timestamp this record was fetched. |

### Use cases

- **Sales intelligence / hiring-signal tracking.** Which companies are hiring for which roles — a leading indicator of growth and budget. Especially useful for the **Nordic/European scale-up segment** Teamtailor dominates, which US-centric ATS datasets miss.
- **Recruiting & talent sourcing.** Aggregate live openings across target employers into one table — same schema as our other four ATS scrapers, so multi-ATS coverage needs zero special-casing.
- **Job boards & aggregators.** Need to *scrape Teamtailor jobs* into a uniform feed? Point it at your company list and ingest normalized records on a schedule.
- **Market & labor research.** Track posting volume, locations, and role mix across a portfolio or market over time (`postedAt`, `country`, `allLocations`).

### Input

| Field | Type | Required | Notes |
|---|---|---|---|
| `companies` | string[] | ✅ | Teamtailor subdomains (`polestar`), `{name}.teamtailor.com` URLs, or full career-site URLs — custom domains work too. One per row. |
| `includeDescription` | boolean | — | Include the full description text. Default `true`. It comes in the same request, so turning it off only trims output size (no change to cost or speed). |
| `maxJobsPerCompany` | integer | — | Cap per company (1–5000). Default `100` — plenty for a first run. |

```json
{
  "companies": ["polestar"],
  "includeDescription": true,
  "maxJobsPerCompany": 100
}
````

### Output sample

A real record from the default run (Polestar's board is multi-country and multi-language — this posting is Danish):

```json
{
  "_type": "job",
  "_schemaVersion": "1.0",
  "_source": "teamtailor",
  "company": "polestar",
  "jobId": "7610594",
  "title": "Customer Engagement Advisor | Denmark",
  "department": null,
  "team": null,
  "location": "Copenhagen, Nordics & UK, DK",
  "allLocations": ["Copenhagen, Nordics & UK, DK"],
  "workplaceType": null,
  "commitment": null,
  "country": "DK",
  "url": "https://polestar.teamtailor.com/jobs/7610594-customer-engagement-advisor-denmark",
  "applyUrl": "https://polestar.teamtailor.com/jobs/7610594-customer-engagement-advisor-denmark",
  "postedAt": "2026-04-21T14:35:06.000Z",
  "updatedAt": null,
  "descriptionText": "Din mulighed \nVi leder lige nu efter en Customer Engagement Advisor, der skal indgå i vores Customer Engagement Team...",
  "_scrapedAt": "2026-06-10T11:29:56.613Z"
}
```

### Use with AI agents (MCP)

This scraper is callable as a tool by AI agents via the **[Apify MCP server](https://mcp.apify.com)** — so assistants like **Claude, Cursor, and VS Code** can run it and use the structured results mid-conversation, with no glue code.

Simplest path: in a recent **Claude Desktop**, add the hosted server `https://mcp.apify.com` under **Settings → Connectors** and authorize with OAuth. For any config-file client:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

Then ask in plain language, e.g. *"List the open jobs on Polestar's Teamtailor career site with titles, locations, and apply links."* — the agent calls **`freshactors/teamtailor-jobs-scraper`** with the right input and reads back the JSON. Full setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

### Pricing

Pay-per-event — **no subscription**. You pay only for the boards you fetch and the postings you receive:

| Event | Price (USD) | When it fires |
|---|---|---|
| **Company jobs fetched** | **$0.02** | Once per company career site successfully fetched (with ≥1 job). |
| **Job posting fetched** | **$0.0005** | Once per job posting returned. |

**Worked example — "how much do 100 results cost?"** Scrape **5 companies** for **100 postings** total:

- Boards: 5 × $0.02 = **$0.10**
- Postings: 100 × $0.0005 = **$0.05**
- **Total: $0.15** for 100 normalized jobs (with full descriptions) across 5 companies.

(Apify platform usage is billed separately per their standard rates.)

### FAQ

**Is scraping Teamtailor jobs legal?**
This actor reads **public, non-personal** job-posting data from companies' own public career sites — the same data those pages serve to any visitor. No login, no personal data. Use responsibly and in line with applicable terms and laws.

**Do I need an API key?**
No. There's no Teamtailor API key, account, or login — it reads the public feed every career site already serves.

**How do I find a company's Teamtailor identifier?**
It's the subdomain in the careers URL — `**polestar**.teamtailor.com`. If the company runs its careers page on its own domain (e.g. `careers.example.com` powered by Teamtailor), just paste that URL — custom domains are fully supported.

**How many jobs can one call return?**
The feed returns the company's **full published board in a single request** — verified on boards of 40+ roles, no pagination needed. (If Teamtailor ever introduces feed pagination, the actor already follows it automatically.) Use `maxJobsPerCompany` to cap volume and cost.

**Does it include full job descriptions?**
Yes — `includeDescription` defaults to `true`, returning each posting's description as clean text. It comes in the same request, so turning it off only trims output size; it doesn't change cost or speed.

**Why are `department` and `commitment` always null?**
Teamtailor's public feed doesn't expose them. We keep the keys (as `null`) so this actor stays drop-in compatible with our other ATS scrapers' shared schema — your pipeline never special-cases a missing column.

**Can I scrape many companies at once?**
Yes — pass as many subdomains/URLs in `companies` as you need. Each board is fetched in isolation; a dead or private board is skipped, not fatal.

**How often is the data updated?**
It's live — every run fetches the companies' current public boards. The actor itself is monitored by a daily canary so parsing stays correct as the feed evolves.

### Other FreshActors tools

| FreshActors actor | What it scrapes |
|---|---|
| [Greenhouse & Lever Jobs Scraper](https://apify.com/freshactors/greenhouse-lever-jobs-scraper) | Greenhouse + Lever — normalized job postings |
| [Workable Jobs Scraper](https://apify.com/freshactors/workable-jobs-scraper) | Workable — normalized job postings, full descriptions |
| [SmartRecruiters Jobs Scraper](https://apify.com/freshactors/smartrecruiters-jobs-scraper) | SmartRecruiters — normalized job postings, full descriptions |
| [Recruitee Jobs Scraper](https://apify.com/freshactors/recruitee-jobs-scraper) | Recruitee — normalized job postings, full descriptions + salary |
| [Personio Jobs Scraper](https://apify.com/freshactors/personio-jobs-scraper) | Personio — normalized job postings, departments + seniority |
| [App Store Scraper](https://apify.com/freshactors/app-store-scraper) | Apple App Store — app details, search, reviews |
| [Google Play Scraper](https://apify.com/freshactors/google-play-scraper) | Google Play — app details + reviews |
| [Microsoft Store Scraper](https://apify.com/freshactors/microsoft-store-scraper) | Microsoft Store — app details, rating windows, search, reviews |
| [VS Code Marketplace Scraper](https://apify.com/freshactors/vscode-marketplace-scraper) | VS Code extensions — install/trending stats, search, reviews |
| [Shopify App Store Scraper](https://apify.com/freshactors/shopify-app-store-scraper) | Shopify App Store — app details, reviews, discovery |
| [Redfin Scraper](https://apify.com/freshactors/redfin-scraper) | Redfin — US real-estate listings |

### Reliability

A scheduled **daily canary** scrapes a known Teamtailor board, validates the normalized schema, and alerts the moment a parse changes. When Teamtailor shifts its public feed, we patch the same day and record it in the changelog below. Every record carries `_schemaVersion` and `_scrapedAt`.

**Changelog**

- **2026-06-10** — v1.0 launch. Single-call public JSON feed (full board + descriptions per request, verified on 40+ -role boards), normalized schema shared with our four other ATS scrapers, custom-domain support, per-company isolation, daily canary monitoring.

**Legal note:** Reads public, non-personal job-posting data from companies' own public career sites (the same data those pages serve to any visitor). No login, no personal data. Use responsibly and in line with applicable terms and laws.

*Found a problem? Open an issue on the actor — issues are answered fast.*

# Actor input Schema

## `companies` (type: `array`):

Teamtailor companies: a subdomain (e.g. oatly), a {name}.teamtailor.com URL, or a full career-site URL (custom domains work too). One per row.

## `includeDescription` (type: `boolean`):

Include the full job description text in each record. Teamtailor returns it in the same request, so turning this off only trims output size — it does not change cost or speed.

## `maxJobsPerCompany` (type: `integer`):

Cap on job postings returned per company (1–5000).

## Actor input object example

```json
{
  "companies": [
    "polestar"
  ],
  "includeDescription": true,
  "maxJobsPerCompany": 100
}
```

# Actor output Schema

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

Normalized job postings.

# 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 = {
    "companies": [
        "polestar"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("freshactors/teamtailor-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 = { "companies": ["polestar"] }

# Run the Actor and wait for it to finish
run = client.actor("freshactors/teamtailor-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 '{
  "companies": [
    "polestar"
  ]
}' |
apify call freshactors/teamtailor-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Teamtailor Jobs Scraper (FreshActors)",
        "description": "Reliable, always-fresh job postings from any Teamtailor career site. Public JSON feed, no login — full descriptions in a single call. Monitored daily. By FreshActors.",
        "version": "1.0",
        "x-build-id": "3Ldu1b7Donfta406a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/freshactors~teamtailor-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-freshactors-teamtailor-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/freshactors~teamtailor-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-freshactors-teamtailor-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/freshactors~teamtailor-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-freshactors-teamtailor-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",
                "required": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies",
                        "type": "array",
                        "description": "Teamtailor companies: a subdomain (e.g. oatly), a {name}.teamtailor.com URL, or a full career-site URL (custom domains work too). One per row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDescription": {
                        "title": "Include full descriptions",
                        "type": "boolean",
                        "description": "Include the full job description text in each record. Teamtailor returns it in the same request, so turning this off only trims output size — it does not change cost or speed.",
                        "default": true
                    },
                    "maxJobsPerCompany": {
                        "title": "Max jobs per company",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap on job postings returned per company (1–5000).",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
