# Built In Jobs Scraper (`scrapeworks/builtin-jobs-scraper`) Actor

Scrape tech and startup jobs from Built In (builtin.com) in bulk: title, company, location, remote type, salary range, seniority, skills and apply URL - one clean row per job. Search by keyword and location; deep pagination with automatic de-duplication.

- **URL**: https://apify.com/scrapeworks/builtin-jobs-scraper.md
- **Developed by:** [Nicolas van Arkens](https://apify.com/scrapeworks) (community)
- **Categories:** Jobs, Business
- **Stats:** 2 total users, 1 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

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/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

## Built In Jobs Scraper

**Scrape tech & startup job listings from [Built In](https://builtin.com/jobs) in bulk** —
by keyword, job title, skill, company, location, or remote status. Get one clean, structured
row per job: title, company, location, remote type, salary range, seniority, required skills,
industries, a short description and the direct apply URL.

Built In is one of the largest tech-focused job boards in the US (Built In, Built In NYC,
Built In Austin, Built In Chicago, Built In LA, Built In Colorado, Built In Boston, Built In
Seattle and more). This actor turns any Built In search into a spreadsheet or a JSON feed —
no login, no API key, no manual copy-paste.

### What you can do with it

- **Sourcing / recruiting** — pull every open "software engineer in Austin" or "data scientist,
  remote" role into a sheet, filter by salary and seniority, and track who's hiring.
- **Sales / lead gen** — find companies that are actively hiring for a stack (React, Kubernetes,
  Snowflake…) — a strong buying signal for dev tools, staffing and services.
- **Market & salary research** — aggregate posted salary ranges by role, city, seniority and
  skill to benchmark compensation and demand.
- **Job aggregators / niche boards** — feed a downstream board or newsletter with fresh,
  structured tech listings.
- **Competitive intelligence** — monitor which roles a set of companies is opening over time.

### Input

Everything takes **arrays**, so one run can cover many keywords and cities at once. Every
`searchTerm` is searched in every `location` (a cross product), and each search is paginated
deep automatically.

| Field | Type | Description |
|---|---|---|
| `searchTerms` | array of strings | Keywords / job titles / skills / company names, e.g. `["software engineer", "python", "product manager"]`. Leave empty to scrape the whole jobs feed. |
| `locations` | array of strings | `"City, ST"` or a city, e.g. `["Austin, TX", "New York, NY"]`. Each term is searched in each location. Empty = nationwide. |
| `remoteOnly` | boolean | `true` = only remote-eligible jobs (Built In's Remote board). |
| `postedWithinDays` | integer | Only jobs posted/updated within N days (e.g. `7`). Omit for all open jobs. |
| `searchUrls` | array of strings | Power users: paste full `builtin.com/jobs` URLs (category pages like `/jobs/dev-engineering`, or any filtered search) and each is paginated deep. |
| `maxResultsPerSearch` | integer | Max jobs per term+location pair (default `300`). Duplicate postings are removed automatically. |
| `proxyConfiguration` | object | Apify Residential/US by default (recommended — the site is behind Cloudflare). |

#### Example input

```json
{
  "searchTerms": ["software engineer", "python"],
  "locations": ["Austin, TX"],
  "remoteOnly": false,
  "maxResultsPerSearch": 50,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
````

### Output

One row per job. Example (real output):

```json
{
  "jobId": "9556889",
  "title": "Associate Propulsion Structures Design Engineer",
  "company": "Boeing",
  "companyUrl": "https://builtin.com/company/boeing",
  "companyLogo": "https://cdn.builtin.com/.../Boeing%20Logo.png",
  "location": "North Charleston, SC, USA",
  "workplaceType": "In-Office",
  "seniority": "Junior",
  "salaryRaw": "85K-115K Annually",
  "salaryMin": 85000,
  "salaryMax": 115000,
  "salaryPeriod": "Annually",
  "postedText": "Reposted A Minute Ago",
  "industries": ["Aerospace", "Information Technology", "Software", "Cybersecurity", "Design", "Defense", "Manufacturing"],
  "skills": ["3-D Computer Aided Design", "Catia", "Enovia", "Pdm"],
  "description": "The Associate Propulsion Structures Design Engineer develops aircraft propulsion structures, ensuring safety and compliance, utilizing design tools, and collaborating with suppliers.",
  "jobUrl": "https://builtin.com/job/associate-propulsion-structures-design-engineer/9556889",
  "searchTerm": "software engineer",
  "searchLocation": "Austin, TX",
  "scrapedAt": "2026-07-19T09:00:00+00:00"
}
```

#### Field reference

| Field | Description |
|---|---|
| `jobId` | Stable Built In job id. |
| `title` | Job title. |
| `company` / `companyUrl` / `companyLogo` | Hiring company, its Built In profile URL, and logo. |
| `location` | Location string as shown (city/state/country, "N Locations", or "Remote"). |
| `workplaceType` | `Remote`, `Hybrid`, `In-Office`, or a combo like `In-Office or Remote`. |
| `seniority` | `Internship`, `Junior`, `Mid level`, `Senior level`, `Expert/Leader`. |
| `salaryRaw` | Salary text as posted (may be empty — salary disclosure is optional). |
| `salaryMin` / `salaryMax` / `salaryPeriod` | Parsed numeric range and period (`Annually`/`Hourly`). |
| `postedText` | Human "posted / reposted X ago" label. |
| `industries` | Company industry tags. |
| `skills` | Top skills listed for the role. |
| `description` | One-line role summary. |
| `jobUrl` | Direct link to the full Built In job posting (where you apply). |
| `searchTerm` / `searchLocation` | Which of your inputs produced this row. |
| `scrapedAt` | UTC timestamp of the scrape. |

### FAQ

**Do I need a Built In login or API key?** No. The jobs board is public and server-rendered.

**How many jobs can I get?** As many as the searches return — each keyword/location paginates
deep (about 25 jobs per page). Scale volume by adding more keywords and locations. A single
Built In search caps at a few hundred results, so use several cities to cover a whole region.

**Are duplicates removed?** Yes. The same posting can appear under several keyword/location
searches; it is de-duplicated by `jobId` across the whole run, so you're never billed twice
for the same job.

**Why is salary sometimes empty?** Many employers don't post a salary range. When Built In
shows one, it's parsed into `salaryMin`/`salaryMax`; otherwise those are `null`.

**Can I apply my own filters (experience level, industry, company size)?** Yes — apply them on
builtin.com in your browser and paste the resulting URL into `searchUrls`; the actor paginates
it deep.

**Is it blocked by anti-bot?** The site is behind Cloudflare. The actor uses Apify Residential
proxy by default and rotates sessions on any block, so runs stay reliable.

# Actor input Schema

## `searchTerms` (type: `array`):

One or more keywords to search Built In jobs for - a job title like 'software engineer', a skill like 'python' or 'react', or a company name. Every search term is run against every location below (so 4 terms x 3 locations = 12 searches), and each search is paginated deep. Results are billed per job row, so more terms = more rows. Leave empty to scrape the whole jobs feed (optionally narrowed by Locations / Remote only).

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

Locations to filter by - 'City, ST' (e.g. 'Austin, TX', 'New York, NY') or just a city. Each search term is searched in each location (a cross product). Leave empty to search every term nationwide. Use 'Remote only' below for remote roles instead of a city.

## `remoteOnly` (type: `boolean`):

If enabled, only remote-eligible jobs are returned (Built In's Remote jobs board). Combine with Search terms to get, e.g., remote Python jobs. Leave off to include in-office and hybrid roles too.

## `postedWithinDays` (type: `integer`):

Optional: only return jobs first posted or updated within this many days (e.g. 1, 7, 14, 30). Leave empty for all open jobs regardless of age.

## `searchUrls` (type: `array`):

Optional: paste full builtin.com/jobs URLs (e.g. 'https://builtin.com/jobs?search=devops\&city=Chicago\&state=IL', a category page like 'https://builtin.com/jobs/dev-engineering', or 'https://builtin.com/jobs/remote') with your own filters already applied in the browser. Each URL is scraped and paginated deep. Use this to apply any Built In filter (experience level, industry, company size, category) that the fields above don't cover.

## `maxResultsPerSearch` (type: `integer`):

Maximum jobs to return for EACH term+location pair (and each pasted URL). The actor paginates automatically (about 25 jobs per page). Set high to pull a whole keyword or location deeply; duplicate jobs (same posting across searches) are removed automatically.

## `proxyConfiguration` (type: `object`):

Proxy used to reach builtin.com. The default (Apify Residential proxy, US) is recommended - the site sits behind Cloudflare and can throttle datacenter traffic at volume. The actor automatically rotates to a fresh proxy session if a page is blocked.

## Actor input object example

```json
{
  "searchTerms": [
    "software engineer",
    "python",
    "data scientist",
    "product manager"
  ],
  "locations": [
    "Austin, TX",
    "New York, NY",
    "San Francisco, CA"
  ],
  "remoteOnly": false,
  "searchUrls": [
    "https://builtin.com/jobs/dev-engineering",
    "https://builtin.com/jobs?search=devops&city=Chicago&state=IL"
  ],
  "maxResultsPerSearch": 300,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "searchTerms": [
        "software engineer"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeworks/builtin-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 = {
    "searchTerms": ["software engineer"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeworks/builtin-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 '{
  "searchTerms": [
    "software engineer"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call scrapeworks/builtin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Built In Jobs Scraper",
        "description": "Scrape tech and startup jobs from Built In (builtin.com) in bulk: title, company, location, remote type, salary range, seniority, skills and apply URL - one clean row per job. Search by keyword and location; deep pagination with automatic de-duplication.",
        "version": "0.1",
        "x-build-id": "8vXIEn95rVWJxCkJv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeworks~builtin-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeworks-builtin-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/scrapeworks~builtin-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeworks-builtin-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/scrapeworks~builtin-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeworks-builtin-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": {
                    "searchTerms": {
                        "title": "Search terms (keyword / job title / skill)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One or more keywords to search Built In jobs for - a job title like 'software engineer', a skill like 'python' or 'react', or a company name. Every search term is run against every location below (so 4 terms x 3 locations = 12 searches), and each search is paginated deep. Results are billed per job row, so more terms = more rows. Leave empty to scrape the whole jobs feed (optionally narrowed by Locations / Remote only).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Locations to filter by - 'City, ST' (e.g. 'Austin, TX', 'New York, NY') or just a city. Each search term is searched in each location (a cross product). Leave empty to search every term nationwide. Use 'Remote only' below for remote roles instead of a city.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "remoteOnly": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "If enabled, only remote-eligible jobs are returned (Built In's Remote jobs board). Combine with Search terms to get, e.g., remote Python jobs. Leave off to include in-office and hybrid roles too.",
                        "default": false
                    },
                    "postedWithinDays": {
                        "title": "Posted within (days)",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Optional: only return jobs first posted or updated within this many days (e.g. 1, 7, 14, 30). Leave empty for all open jobs regardless of age."
                    },
                    "searchUrls": {
                        "title": "Built In job URLs (optional, power users)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional: paste full builtin.com/jobs URLs (e.g. 'https://builtin.com/jobs?search=devops&city=Chicago&state=IL', a category page like 'https://builtin.com/jobs/dev-engineering', or 'https://builtin.com/jobs/remote') with your own filters already applied in the browser. Each URL is scraped and paginated deep. Use this to apply any Built In filter (experience level, industry, company size, category) that the fields above don't cover.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerSearch": {
                        "title": "Max results per search",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum jobs to return for EACH term+location pair (and each pasted URL). The actor paginates automatically (about 25 jobs per page). Set high to pull a whole keyword or location deeply; duplicate jobs (same posting across searches) are removed automatically.",
                        "default": 300
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach builtin.com. The default (Apify Residential proxy, US) is recommended - the site sits behind Cloudflare and can throttle datacenter traffic at volume. The actor automatically rotates to a fresh proxy session if a page is blocked.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
