# Global Jobs Search API - 2.5M+ Direct ATS Jobs (`thirdwatch/global-jobs-search`) Actor

Search 2.5M+ live jobs normalized from 38 direct ATS sources. Filter by role, company, location, salary, remote status, employment type, skills, date, and source; receive canonical apply URLs.

- **URL**: https://apify.com/thirdwatch/global-jobs-search.md
- **Developed by:** [Thirdwatch](https://apify.com/thirdwatch) (community)
- **Categories:** Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 job results

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

## Global Jobs Search API — 2.5M+ Direct ATS Jobs

> Search more than 2.5 million live jobs from 38 direct ATS sources and export normalized titles, companies, locations, salaries, skills, descriptions, work arrangements, and canonical apply URLs.

### What you get from the Global Jobs Search API

Search a continuously maintained global jobs index instead of configuring individual company career pages. Combine keywords with company, title, country, city, source, posting date, salary, employment type, and remote-work filters, then export the matching jobs as JSON, CSV, Excel, XML, RSS, or HTML.

Results use one normalized schema across all 38 supported ATS sources. Each row preserves the direct application URL and includes source information, location normalization, role taxonomy, enrichment provenance, duplicate grouping, and full description text when requested.

#### Quick start

1. Enter a role, skill, company, or other search phrase in `query`.
2. Narrow the search with location, company, salary, date, employment type, or work-arrangement filters.
3. Keep descriptions disabled for compact discovery runs, or enable them for downstream analysis.
4. Set the result limit and click **Start**.
5. Export the dataset or connect it to a scheduled recruiting, sales, or market-intelligence workflow.

### Global jobs output fields

| Field | Description |
|---|---|
| `job_key` | Stable normalized job identifier |
| `external_id` | Identifier supplied by the originating hiring system, when available |
| `title` | Public job title |
| `title_clean` | Normalized job title |
| `organization` | Hiring company or organization |
| `company_key` | Normalized company identifier, when available |
| `url` | Canonical direct application URL |
| `status` | Current indexed job status |
| `closed_at` | Closure timestamp, when applicable |
| `close_reason` | Recorded reason for closure, when available |
| `first_seen` | First time the job was observed |
| `last_seen` | Most recent observation time |
| `date_posted` | Public posting date, when available |
| `locations` | Original public location labels |
| `locations_derived` | Structured city, country, country code, latitude, and longitude records |
| `countries_derived` | Normalized country names or codes |
| `remote_derived` | Whether the role is identified as remote, when available |
| `work_arrangement_derived` | Normalized `remote`, `hybrid`, `on_site`, or `unknown` arrangement |
| `employment_type` | Normalized employment types such as full-time, contract, or internship |
| `language_derived` | Detected job language, when available |
| `experience_level_derived` | Normalized experience level, when available |
| `skills_derived` | Skills extracted from the job posting |
| `benefits_derived` | Benefits extracted from the posting |
| `department` | Hiring department or team, when available |
| `has_salary` | Whether structured salary information is present |
| `salary` | Original public salary text, when available |
| `salary_min_derived` | Normalized minimum salary |
| `salary_max_derived` | Normalized maximum salary |
| `salary_currency_derived` | Normalized salary currency |
| `salary_period_derived` | Salary period such as year, month, or hour |
| `salary_derived` | Combined structured salary object, when available |
| `taxonomy` | Normalized role family, subfamily, and skill clusters |
| `description_snippet` | Compact job-description excerpt |
| `description_text` | Full job description when `includeDescriptions` is enabled |
| `duplicate_group_id` | Identifier linking duplicate representations of the same opening |
| `enrichment_tier` | Data-enrichment level applied to the record |
| `enrichment_provenance` | Source, confidence, and timestamp for derived fields |
| `source` | Originating ATS family |
| `source_slug` | Source board or tenant identifier |
| `source_endpoint` | Public source endpoint associated with the job |
| `directory_verified_at` | Most recent source-directory verification time |

Optional fields remain absent or empty when the employer or source does not publish them.

### Example global job output

```json
{
  "job_key": "greenhouse:acme:4582197",
  "title": "Senior Data Engineer",
  "title_clean": "Senior Data Engineer",
  "organization": "Acme Analytics",
  "url": "https://boards.greenhouse.io/acme/jobs/4582197",
  "status": "open",
  "date_posted": "2026-07-14T09:30:00Z",
  "locations": ["London, United Kingdom"],
  "locations_derived": [
    {
      "city": "London",
      "country": "United Kingdom",
      "country_code": "GB",
      "lat": 51.5072,
      "lng": -0.1276
    }
  ],
  "countries_derived": ["GB"],
  "remote_derived": true,
  "work_arrangement_derived": "hybrid",
  "employment_type": ["FULL_TIME"],
  "skills_derived": ["Python", "SQL", "Airflow"],
  "has_salary": true,
  "salary_min_derived": 85000,
  "salary_max_derived": 105000,
  "salary_currency_derived": "GBP",
  "salary_period_derived": "year",
  "taxonomy": {
    "family": "engineering_technology",
    "subfamily": "data_engineering",
    "skill_clusters": ["data_platforms", "analytics_engineering"]
  },
  "description_snippet": "Build and operate reliable data products used across the company...",
  "source": "greenhouse"
}
````

### Global Jobs Search API input parameters

| Parameter | Required | Default | Description |
|---|---:|---|---|
| `query` | No | `data engineer` | Role, skill, company, or free-text search. At least one search or filter is recommended. |
| `title` | No | — | Normalized job-title filter. |
| `country` | No | — | Country name or two-letter code such as `US`, `GB`, `Germany`, or `India`. |
| `city` | No | — | City filter. |
| `company` | No | — | Employer-name filter. |
| `atsSource` | No | — | ATS source such as `workday`, `greenhouse`, `lever`, `ashby`, or `smartrecruiters`. |
| `postedSince` | No | — | Earliest posting time in ISO format, such as `2026-07-01T00:00:00Z`. |
| `hasSalary` | No | `false` | Set to `true` to return only jobs with structured salary data. |
| `minimumSalary` | No | — | Minimum structured salary value. Combine with location and currency-aware analysis. |
| `employmentType` | No | — | Employment type such as `full_time`, `part_time`, `contract`, or `internship`. |
| `workArrangement` | No | — | Work arrangement such as `remote`, `hybrid`, or `on_site`. |
| `excludeDuplicates` | No | `true` | Collapse the same opening found through multiple source URLs. |
| `includeDescriptions` | No | `false` | Include full description text instead of compact snippets only. |
| `maxResults` | No | `25` | Maximum jobs returned across the complete search, from 1 to 100,000. |

#### Example input

```json
{
  "query": "data engineer",
  "country": "GB",
  "city": "London",
  "postedSince": "2026-07-01T00:00:00Z",
  "hasSalary": true,
  "workArrangement": "hybrid",
  "excludeDuplicates": true,
  "includeDescriptions": true,
  "maxResults": 500
}
```

### Global job data use cases

- **Recruiters and staffing teams:** Discover fresh openings by role, location, company, and employment type.
- **Job boards and aggregators:** Populate normalized listings with canonical application URLs from many ATS sources.
- **Sales and market-intelligence teams:** Identify companies hiring for relevant teams, skills, or locations.
- **Workforce researchers:** Analyze demand for roles, skills, compensation, and work arrangements across markets.
- **Developers and AI teams:** Build job alerts, matching systems, search products, analytics, and retrieval pipelines.

### Global Jobs Search API limitations

- The index reflects publicly available employer postings and can lag a source between refreshes.
- Salary, skills, experience, benefits, and exact posting dates are unavailable when an employer does not publish enough information.
- `minimumSalary` compares normalized values; account for currency and salary period when combining multiple markets.
- Full descriptions increase dataset size and are only returned when `includeDescriptions` is enabled.
- Very broad searches can produce many valid matches. Use title, company, location, source, date, or work-arrangement filters for more targeted datasets.
- Canonical application URLs can expire after an employer closes or replaces a posting.

### Compared to other ATS jobs scrapers

- Compared with `bovi/greenhouse-lever-ashby-job-scraper`, this Actor searches an existing index spanning 38 ATS sources instead of requiring users to supply company slugs across six supported systems.
- Compared with `fantastic-jobs/jobs-scraper`, this Actor is built for cross-company keyword and attribute search rather than collecting jobs from user-provided career-page URLs.
- Choose this Actor when discovery and normalized search across a large jobs index matter. Choose a career-page crawler when you need to target a specific company board that is not yet represented in the index.

### Global Jobs Search API FAQ

#### Do I need to provide company career-site URLs?

No. Search the existing jobs index by keywords and filters. Use `company` or `atsSource` when you want to narrow the source set.

#### Can I return more than 1,000 jobs?

Yes. Set `maxResults` as high as 100,000. The Actor continues through available result pages and writes all accepted jobs to one dataset.

#### Can I search only remote jobs with salaries?

Yes. Set `workArrangement` to `remote` and `hasSalary` to `true`, then add role and location filters as needed.

#### Are application links direct?

The dataset preserves the canonical public application URL supplied by the originating ATS whenever available.

#### How do I get full job descriptions?

Set `includeDescriptions` to `true`. Otherwise, each result uses the compact `description_snippet` field to keep discovery datasets smaller.

#### Can I schedule new-job monitoring?

Yes. Combine `postedSince` with an Apify schedule, then send each dataset to a webhook, database, spreadsheet, Slack workflow, or another integration.

### Related Thirdwatch Actors

- [Career Sites Scraper](https://apify.com/thirdwatch/career-site-scraper) — collect jobs from specific employer career pages
- [LinkedIn Jobs Scraper](https://apify.com/thirdwatch/linkedin-jobs-scraper) — LinkedIn job search and detail data
- [Indeed Jobs Scraper](https://apify.com/thirdwatch/indeed-jobs-scraper) — Indeed listings, descriptions, salary, and remote fields

Explore more recruiting and labor-market data tools from [Thirdwatch](https://thirdwatch.dev/).

**Last verified: 2026-07**

# Actor input Schema

## `query` (type: `string`):

Role, skill, company, or free-text job search.

## `title` (type: `string`):

Optional normalized job-title filter.

## `country` (type: `string`):

Country name or two-letter code such as US, GB, Germany, or India.

## `city` (type: `string`):

Optional city filter.

## `company` (type: `string`):

Optional employer-name filter.

## `atsSource` (type: `string`):

Source such as workday, greenhouse, lever, ashby, or smartrecruiters.

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

ISO date/time such as 2026-07-01T00:00:00Z.

## `hasSalary` (type: `boolean`):

Exclude jobs without structured salary data.

## `minimumSalary` (type: `number`):

Optional minimum structured salary value.

## `employmentType` (type: `string`):

For example full\_time, part\_time, contract, or internship.

## `workArrangement` (type: `string`):

For example remote, hybrid, or on\_site.

## `excludeDuplicates` (type: `boolean`):

Collapse the same opening found through multiple source URLs.

## `includeDescriptions` (type: `boolean`):

Include full descriptions instead of compact snippets.

## `maxResults` (type: `integer`):

Maximum jobs returned across cursor pages.

## Actor input object example

```json
{
  "query": "data engineer",
  "hasSalary": false,
  "excludeDuplicates": true,
  "includeDescriptions": false,
  "maxResults": 25
}
```

# Actor output Schema

## `results` (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 = {
    "query": "data engineer",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("thirdwatch/global-jobs-search").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 = {
    "query": "data engineer",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("thirdwatch/global-jobs-search").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 '{
  "query": "data engineer",
  "maxResults": 25
}' |
apify call thirdwatch/global-jobs-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Global Jobs Search API - 2.5M+ Direct ATS Jobs",
        "description": "Search 2.5M+ live jobs normalized from 38 direct ATS sources. Filter by role, company, location, salary, remote status, employment type, skills, date, and source; receive canonical apply URLs.",
        "version": "1.1",
        "x-build-id": "V9Y5lCeaBYDSxpDUM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thirdwatch~global-jobs-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thirdwatch-global-jobs-search",
                "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/thirdwatch~global-jobs-search/runs": {
            "post": {
                "operationId": "runs-sync-thirdwatch-global-jobs-search",
                "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/thirdwatch~global-jobs-search/run-sync": {
            "post": {
                "operationId": "run-sync-thirdwatch-global-jobs-search",
                "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": {
                    "query": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Role, skill, company, or free-text job search."
                    },
                    "title": {
                        "title": "Job Title",
                        "type": "string",
                        "description": "Optional normalized job-title filter."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Country name or two-letter code such as US, GB, Germany, or India."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Optional city filter."
                    },
                    "company": {
                        "title": "Company",
                        "type": "string",
                        "description": "Optional employer-name filter."
                    },
                    "atsSource": {
                        "title": "ATS Source",
                        "type": "string",
                        "description": "Source such as workday, greenhouse, lever, ashby, or smartrecruiters."
                    },
                    "postedSince": {
                        "title": "Posted Since",
                        "type": "string",
                        "description": "ISO date/time such as 2026-07-01T00:00:00Z."
                    },
                    "hasSalary": {
                        "title": "Only Jobs with Salary",
                        "type": "boolean",
                        "description": "Exclude jobs without structured salary data.",
                        "default": false
                    },
                    "minimumSalary": {
                        "title": "Minimum Salary",
                        "minimum": 0,
                        "type": "number",
                        "description": "Optional minimum structured salary value."
                    },
                    "employmentType": {
                        "title": "Employment Type",
                        "type": "string",
                        "description": "For example full_time, part_time, contract, or internship."
                    },
                    "workArrangement": {
                        "title": "Work Arrangement",
                        "type": "string",
                        "description": "For example remote, hybrid, or on_site."
                    },
                    "excludeDuplicates": {
                        "title": "Exclude Duplicates",
                        "type": "boolean",
                        "description": "Collapse the same opening found through multiple source URLs.",
                        "default": true
                    },
                    "includeDescriptions": {
                        "title": "Include Descriptions",
                        "type": "boolean",
                        "description": "Include full descriptions instead of compact snippets.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum jobs returned across cursor pages.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
