# Ashby Jobs Scraper (`automation-lab/ashby-jobs-scraper`) Actor

Extract Ashby job postings with departments, locations, salary summaries, descriptions, and apply URLs from public career boards.

- **URL**: https://apify.com/automation-lab/ashby-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Ashby Jobs Scraper

Extract structured job postings from public Ashby career boards.

Ashby Jobs Scraper turns `https://jobs.ashbyhq.com/<company>` boards into clean dataset rows with titles, departments, locations, workplace types, salary summaries, descriptions, and apply URLs.

Use it when you need reliable recruiting intelligence from startup and SaaS companies that host careers pages on Ashby.

### What does Ashby Jobs Scraper do?

Ashby Jobs Scraper reads public Ashby-hosted job boards and exports each posting as a structured record.

It accepts Ashby board URLs such as `https://jobs.ashbyhq.com/ashby` or direct company slugs such as `ashby`.

For each job, it can fetch the listing summary and the detailed job posting content.

The actor is HTTP/API-first and uses Ashby's public non-user job-board GraphQL endpoints rather than a browser.

That makes it faster and cheaper than browser automation for normal career-board monitoring workflows.

### Who is it for?

Recruiting intelligence teams use this actor to monitor which startups are hiring and which departments are expanding.

Job board operators use it to ingest current Ashby postings into niche job boards and newsletters.

Sales teams use it to identify hiring signals that indicate budget, growth, or new team formation.

Data teams use it to normalize job postings from Ashby alongside Greenhouse, Workday, Workable, Lever, and other ATS sources.

Investors and market researchers use it to track talent demand across portfolio companies and market segments.

### Why use it?

Ashby career pages are public but optimized for candidates, not bulk analysis.

This actor extracts repeatable machine-readable rows from those pages.

It preserves important recruiting fields such as department, location, employment type, workplace type, compensation summary, and application link.

It also includes source URLs so you can audit each row and deduplicate against other job feeds.

### Data you can extract

| Field | Description |
| --- | --- |
| `companySlug` | Ashby hosted jobs page name |
| `jobId` | Ashby job posting ID |
| `title` | Job title |
| `departmentName` | Department or nested team path |
| `teamNames` | Team names from the detailed posting |
| `locationName` | Primary job location |
| `secondaryLocationNames` | Additional locations when listed |
| `employmentType` | Full-time, part-time, contract, or similar Ashby value |
| `workplaceType` | Remote, hybrid, onsite, or similar Ashby value |
| `compensationTierSummary` | Public compensation summary when available |
| `scrapeableCompensationSalarySummary` | Normalized public salary summary when Ashby exposes it |
| `applicationDeadline` | Application deadline when available |
| `jobUrl` | Public posting URL |
| `applyUrl` | Public application URL |
| `descriptionHtml` | Full job description HTML when enabled |
| `descriptionText` | Plain-text job description when enabled |
| `scrapedAt` | ISO timestamp of extraction |

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

The actor uses pay-per-event pricing.

There is a small run-start charge and a per-job charge for each saved dataset item.

Validated production pricing is configured as:

- Run start: `$0.005`
- Job item: tiered, with BRONZE at `$0.001` per saved job

The per-job price uses standard Apify account-tier discounts from FREE through DIAMOND.

Always check the Apify pricing panel for the live price that applies to your account tier.

### Input options

You can provide board URLs, company slugs, or both.

`boardUrls` is best when you copy URLs directly from a browser.

`companySlugs` is best when you already have normalized Ashby identifiers from another system.

`maxItems` limits how many job rows are saved across all boards.

`includeDescription` controls whether the actor fetches detailed posting records.

`departmentFilter` filters jobs by department or team name.

`locationFilter` filters jobs by primary or secondary location.

### Example input: scrape one Ashby board

```json
{
  "boardUrls": ["https://jobs.ashbyhq.com/ashby"],
  "maxItems": 25,
  "includeDescription": true
}
````

### Example input: monitor engineering roles

```json
{
  "companySlugs": ["ashby"],
  "maxItems": 50,
  "includeDescription": false,
  "departmentFilter": "Engineering"
}
```

### Example input: remote hiring signal

```json
{
  "boardUrls": ["https://jobs.ashbyhq.com/ashby"],
  "maxItems": 100,
  "includeDescription": true,
  "locationFilter": "Remote"
}
```

### Output example

```json
{
  "companySlug": "ashby",
  "jobId": "f8af6d8b-3f86-4b4f-90db-839b9ae5be7e",
  "title": "Business Development Representative - EMEA",
  "departmentName": "Sales",
  "locationName": "Remote - European Union",
  "employmentType": "FullTime",
  "workplaceType": "Remote",
  "compensationTierSummary": "€55,250 – €90,000 • Offers Equity • Offers Commission • Multiple Ranges",
  "jobUrl": "https://jobs.ashbyhq.com/ashby/f8af6d8b-3f86-4b4f-90db-839b9ae5be7e",
  "applyUrl": "https://jobs.ashbyhq.com/ashby/f8af6d8b-3f86-4b4f-90db-839b9ae5be7e/application"
}
```

### How to run

1. Open the actor on Apify.
2. Paste one or more Ashby board URLs.
3. Set a small `maxItems` value for your first test.
4. Keep `includeDescription` enabled if you need full job descriptions.
5. Start the run.
6. Export results from the default dataset as JSON, CSV, Excel, or through the API.

### Tips for better results

Use exact Ashby board URLs from `jobs.ashbyhq.com` when possible.

Keep `maxItems` low for smoke tests and raise it for scheduled monitoring.

Disable `includeDescription` when you only need titles, locations, and apply URLs.

Use `departmentFilter` for focused hiring signals such as Engineering, Sales, Product, or Customer Success.

Use `locationFilter` for remote-market workflows.

### Integrations

Send dataset rows to Google Sheets for lightweight hiring trackers.

Push output into a data warehouse for trend analysis across ATS platforms.

Connect the actor to Zapier or Make to alert sales teams when target accounts open new roles.

Use Apify webhooks to trigger downstream enrichment when new postings appear.

Combine this actor with company enrichment tools to attach firmographic data to each hiring signal.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ashby-jobs-scraper').call({
  boardUrls: ['https://jobs.ashbyhq.com/ashby'],
  maxItems: 25,
  includeDescription: true,
});

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

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/ashby-jobs-scraper').call(run_input={
    'boardUrls': ['https://jobs.ashbyhq.com/ashby'],
    'maxItems': 25,
    'includeDescription': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~ashby-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"boardUrls":["https://jobs.ashbyhq.com/ashby"],"maxItems":25,"includeDescription":true}'
```

### MCP usage

You can use this actor through Apify MCP from Claude Desktop, Claude Code, or other MCP-compatible tools.

MCP server URL:

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

Add it in Claude Code with:

```bash
claude mcp add ashby-jobs-scraper https://mcp.apify.com/?tools=automation-lab/ashby-jobs-scraper
```

Claude Desktop JSON configuration:

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

Example prompts:

- "Scrape the Ashby career board for this company and summarize remote engineering roles."
- "Monitor these Ashby job boards and return titles, departments, locations, and apply URLs."
- "Extract salary ranges from public Ashby postings for these startup career pages."

### Scheduling

For monitoring, schedule the actor daily or weekly.

Use the same board URL list each time and compare dataset exports by `jobId`.

Downstream systems can treat new `jobId` values as newly opened roles.

Closed roles are detected by comparing the latest run against earlier snapshots.

### Reliability notes

The actor targets public Ashby job-board endpoints.

It does not log in, bypass private data, or access candidate-only areas.

If a company removes or renames its Ashby board, the actor will report that no public board was found.

Some postings may not expose salary or application deadlines.

### Limitations

The actor only supports public Ashby-hosted career pages.

It does not scrape private Ashby admin dashboards.

It does not submit applications.

It does not enrich companies beyond the data available on the public job board.

Description extraction requires one additional request per saved job.

### Troubleshooting

If a run returns zero items, verify that the board URL is public and starts with `https://jobs.ashbyhq.com/`.

If filters remove too many results, clear `departmentFilter` and `locationFilter` and rerun a small test.

If salary fields are empty, the employer likely did not publish compensation data on that posting.

If descriptions are missing, enable `includeDescription`.

### Legality

This actor extracts public job-posting data intended for candidates and search engines.

You are responsible for using the data in compliance with applicable laws, website terms, and privacy obligations.

Avoid collecting or processing personal candidate data unless you have a lawful basis.

Do not use the actor to spam employers or applicants.

### Related scrapers

Other ATS and jobs actors in the Automation Lab portfolio:

- [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper)
- [Workday Jobs Scraper](https://apify.com/automation-lab/workday-jobs-scraper)
- [Workable Jobs Scraper](https://apify.com/automation-lab/workable-jobs-scraper)
- [Y Combinator Jobs Scraper](https://apify.com/automation-lab/ycombinator-jobs-scraper)

Use those actors when the target company uses a different ATS.

### FAQ

#### Can I scrape any Ashby company?

You can scrape public boards hosted on `jobs.ashbyhq.com` when they are visible without login.

#### Does it need a proxy?

No proxy is required for the current HTTP/API implementation.

#### Can I get full descriptions?

Yes. Set `includeDescription` to `true` to fetch detailed posting records.

#### Can I scrape multiple companies in one run?

Yes. Add multiple board URLs or slugs. `maxItems` applies across the whole run.

#### Why is compensation sometimes empty?

Ashby only exposes compensation fields when the employer publishes them.

#### Is this a browser scraper?

No. It uses public HTTP requests, which makes runs faster and cheaper.

### Support

If a public Ashby board fails, include the board URL, run ID, and a short description of the missing fields in your support request.

Small reproducible inputs help resolve issues faster.

# Actor input Schema

## `boardUrls` (type: `array`):

Public Ashby job board URLs to scrape, for example https://jobs.ashbyhq.com/ashby.

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

Ashby hosted jobs page names. Use this instead of URLs if you already know the slug, for example ashby.

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

Maximum job postings to save across all boards.

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

Fetch each job detail record to include description, detailed salary summary, application deadline, and team names.

## `departmentFilter` (type: `string`):

Optional case-insensitive substring filter for department/team names, for example Engineering.

## `locationFilter` (type: `string`):

Optional case-insensitive substring filter for primary or secondary job locations, for example Remote or London.

## Actor input object example

```json
{
  "boardUrls": [
    "https://jobs.ashbyhq.com/ashby"
  ],
  "companySlugs": [],
  "maxItems": 20,
  "includeDescription": 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 = {
    "boardUrls": [
        "https://jobs.ashbyhq.com/ashby"
    ],
    "companySlugs": [],
    "maxItems": 20,
    "includeDescription": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ashby-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 = {
    "boardUrls": ["https://jobs.ashbyhq.com/ashby"],
    "companySlugs": [],
    "maxItems": 20,
    "includeDescription": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ashby-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 '{
  "boardUrls": [
    "https://jobs.ashbyhq.com/ashby"
  ],
  "companySlugs": [],
  "maxItems": 20,
  "includeDescription": true
}' |
apify call automation-lab/ashby-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ashby Jobs Scraper",
        "description": "Extract Ashby job postings with departments, locations, salary summaries, descriptions, and apply URLs from public career boards.",
        "version": "0.1",
        "x-build-id": "XxhcypckIe7tXjdAZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ashby-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ashby-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~ashby-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ashby-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~ashby-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ashby-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": {
                    "boardUrls": {
                        "title": "Ashby board URLs",
                        "type": "array",
                        "description": "Public Ashby job board URLs to scrape, for example https://jobs.ashbyhq.com/ashby.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companySlugs": {
                        "title": "Company slugs",
                        "type": "array",
                        "description": "Ashby hosted jobs page names. Use this instead of URLs if you already know the slug, for example ashby.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum job postings to save across all boards.",
                        "default": 20
                    },
                    "includeDescription": {
                        "title": "Include job descriptions",
                        "type": "boolean",
                        "description": "Fetch each job detail record to include description, detailed salary summary, application deadline, and team names.",
                        "default": true
                    },
                    "departmentFilter": {
                        "title": "Department filter",
                        "type": "string",
                        "description": "Optional case-insensitive substring filter for department/team names, for example Engineering."
                    },
                    "locationFilter": {
                        "title": "Location filter",
                        "type": "string",
                        "description": "Optional case-insensitive substring filter for primary or secondary job locations, for example Remote or London."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
