# Career Page Job Postings Scraper (`fetch_cat/career-page-job-postings-scraper`) Actor

Scrape public company career pages and linked ATS job listings into normalized job posting datasets.

- **URL**: https://apify.com/fetch\_cat/career-page-job-postings-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 job record saveds

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

## Career Page Job Postings Scraper

Extract public job postings from company career pages and linked applicant tracking system (ATS) job pages. Use it to monitor hiring signals, build recruiting lead lists, enrich company data, or track labor-market changes without manually checking every careers page.

### Value proposition

Career Page Job Postings Scraper turns messy public careers pages into a clean job-posting dataset you can plug into recruiting, sales, market-intelligence, and alerting workflows.

### What does it do?

- Starts from one or more public company careers URLs.
- Detects job posting links on the page.
- Optionally follows linked public job detail pages.
- Normalizes every saved job into one dataset with consistent fields.
- Keeps going when one URL is blocked or returns no jobs, so you can process mixed lists safely.

### Example input

```json
{
  "startUrls": [
    { "url": "https://stripe.com/jobs/search" },
    { "url": "https://www.notion.com/careers" }
  ],
  "maxItems": 50,
  "maxPagesPerSite": 25,
  "includeDetails": true,
  "sameDomainOnly": true,
  "keywords": ["engineer", "sales"],
  "excludeKeywords": ["intern"]
}
````

### Example output

```json
{
  "companyName": "Notion",
  "sourceUrl": "https://www.notion.com/careers",
  "jobUrl": "https://jobs.ashbyhq.com/notion/05e14247-17c4-4e98-9a13-53828a4e2f13",
  "title": "Outbound Business Development Representative, AMER",
  "department": null,
  "team": null,
  "location": "New York, New York",
  "workplaceType": null,
  "employmentType": null,
  "postedAt": null,
  "descriptionText": null,
  "applyUrl": "https://jobs.ashbyhq.com/notion/05e14247-17c4-4e98-9a13-53828a4e2f13",
  "salaryText": null,
  "atsVendor": "ashbyhq",
  "extractionMethod": "job-link",
  "scrapedAt": "2026-07-12T14:02:42.961Z"
}
```

### Input settings

| Field | Type | Description |
|---|---:|---|
| `startUrls` | array | Public career page URLs to scan. |
| `maxItems` | integer | Maximum saved job records across all URLs. |
| `maxPagesPerSite` | integer | Maximum pages fetched per start URL, including linked job detail pages. |
| `includeDetails` | boolean | Follow detected public job pages to enrich records when possible. |
| `keywords` | array | Save only jobs matching at least one keyword in title, URL, location, or description. |
| `excludeKeywords` | array | Skip jobs matching any excluded keyword. |
| `sameDomainOnly` | boolean | Follow same-domain links plus recognized public ATS job hosts linked from the career page. |
| `resumePending` | boolean | Continue the source URLs recorded in `PENDING_WORK` after a prior run ended its time budget. |

### Output fields

- `companyName` - inferred company name when available.
- `stableId` - stable ATS ID when the public source provides one, otherwise a canonical job URL identifier.
- `sourceUrl` - original career page URL.
- `jobUrl` - canonical job posting URL.
- `title` - job title.
- `department`, `team` - department/team when detected.
- `location` - job location text when detected.
- `workplaceType` - remote/hybrid/on-site signal when detected.
- `employmentType` - full-time, part-time, contract, or internship signal when detected.
- `postedAt` - posted date when available.
- `descriptionText` - plain-text job description when detail extraction is available.
- `applyUrl` - application or job detail URL.
- `salaryText` - salary/pay range text when present.
- `atsVendor` - detected ATS vendor such as Ashby, Greenhouse, Lever, or Workable.
- `extractionMethod` - how the record was found.
- `scrapedAt` - ISO timestamp for the scrape.

### Pricing

This actor uses pay-per-event pricing:

- Run start: `$0.005` per run.
- Saved job record: about `$0.50` per 1,000 saved jobs before volume discounts.

| Tier | Price per saved job | Approx. per 1,000 jobs |
|---|---:|---:|
| Free | `$0.000575` | 0.575 USD |
| Bronze | `$0.000500` | 0.500 USD |
| Silver | `$0.000390` | 0.390 USD |
| Gold | `$0.000300` | 0.300 USD |
| Platinum | `$0.000200` | 0.200 USD |
| Diamond | `$0.000140` | 0.140 USD |

### Who is it for

- Recruiting teams tracking hiring demand across target companies.
- Sales and lead generation teams looking for expansion or budget signals.
- Labor-market analysts monitoring role, department, and location trends.
- Data teams that need repeatable career-page data in a normalized format.

### Use cases

- Monitor target accounts for new hiring signals.
- Build recruiter sourcing lists from public company websites.
- Track competitor hiring by department, location, or role family.
- Feed data warehouses with normalized public job posting records.
- Trigger alerts when target companies add matching roles.

### Tips for best results

- Use public careers or jobs pages, not login-only applicant portals.
- Greenhouse, Lever, and Ashby board URLs use their public job-listing responses when available; other public career pages use bounded page discovery.
- Keep `sameDomainOnly` enabled unless you intentionally want broader crawling.
- Use `keywords` to focus large career sites on specific teams or roles.
- Increase `maxPagesPerSite` for companies with many paginated job listings.

### Limits and responsible use

The actor only works with publicly reachable job listings. It does not use user cookies, private accounts, paid credentials, applicant records, or application endpoints. It rejects private/local network URLs and reports blocked, challenge, unavailable, and all-source failures instead of treating them as successful empty exports. A multi-source run can retain valid rows while recording failed sources in `RUN_SUMMARY`; a hard deadline saves `PENDING_WORK` for an opt-in follow-up run.

### Legality

This actor is intended for public job-posting data. Always respect website terms, robots and access rules where applicable, privacy requirements, and employment-data regulations in your jurisdiction. Do not use it to collect private applicant data or access information behind authentication.

### API usage

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('<ANNA_APIFY_USERNAME>/career-page-job-postings-scraper').call({
  startUrls: [{ url: 'https://stripe.com/jobs/search' }],
  maxItems: 50,
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('<ANNA_APIFY_USERNAME>/career-page-job-postings-scraper').call(run_input={
    'startUrls': [{'url': 'https://stripe.com/jobs/search'}],
    'maxItems': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/<ANNA_APIFY_USERNAME>~career-page-job-postings-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://stripe.com/jobs/search"}],"maxItems":50}'
```

### MCP and agent usage

Use this actor from Apify MCP to let AI agents monitor career pages and retrieve structured job postings. Connect compatible AI clients through `https://mcp.apify.com/?tools=<ANNA_APIFY_USERNAME>/career-page-job-postings-scraper`.

CLI setup:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=<ANNA_APIFY_USERNAME>/career-page-job-postings-scraper"
```

JSON config example:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=<ANNA_APIFY_USERNAME>/career-page-job-postings-scraper"
    }
  }
}
```

Example prompts:

- "Find public sales and engineering jobs from these company career pages."
- "Monitor this list of career URLs and return new remote roles."
- "Extract normalized job postings and include job URLs and locations."

### Related actors

- [Google Maps Places Scraper](https://apify.com/fetch_cat/google-maps-places-scraper) - enrich companies and local hiring targets.
- [Dice Jobs Scraper](https://apify.com/fetch_cat/dice-jobs-scraper) - collect technology job postings from Dice.
- [Booking.com Hotels Scraper](https://apify.com/fetch_cat/booking-com-hotels-scraper) - monitor travel and hospitality businesses.

### FAQ

**Can it scrape every career site?**\
No. Career pages vary widely. The actor is designed to return partial results and skip blocked pages instead of failing the whole run.

**Does it need proxies or cookies?**\
No cookies are required. The first version is HTTP-first and targets public pages.

**Can I filter by role or location?**\
Yes. Use `keywords` and `excludeKeywords`; filtering checks title, URL, location, and description when available.

**Will it follow ATS links?**\
Yes. With `includeDetails` enabled it can follow public ATS job URLs linked from the career page, subject to `maxPagesPerSite`.

### Support

Questions or missing fields? Open an issue on the actor page and include:

- The run ID or run URL.
- The input JSON you used.
- The public career page URL you expected to scrape.
- The expected output and actual output you received.
- Any reproducible public URL that demonstrates the missing or incorrect job data.

# Actor input Schema

## `startUrls` (type: `array`):

Public company careers or jobs pages to scan for job postings.

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

Stop after saving this many job posting records across all start URLs.

## `maxPagesPerSite` (type: `integer`):

Maximum pages to fetch from each career site, including linked public job detail pages.

## `includeDetails` (type: `boolean`):

Follow public job links to enrich records with description, location, department, salary, and apply URL when available.

## `keywords` (type: `array`):

Only save jobs whose title, URL, location, or description contains at least one keyword. Leave empty to include all detected jobs.

## `excludeKeywords` (type: `array`):

Skip jobs whose title, URL, location, or description contains any of these keywords.

## `sameDomainOnly` (type: `boolean`):

When enabled, only follow links on the same domain plus recognized public ATS hosts linked from the career page.

## `resumePending` (type: `boolean`):

When a previous run saved a PENDING\_WORK checkpoint because its time budget ended, continue only those remaining source URLs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://stripe.com/jobs/search"
    },
    {
      "url": "https://www.notion.com/careers"
    }
  ],
  "maxItems": 10,
  "maxPagesPerSite": 10,
  "includeDetails": true,
  "sameDomainOnly": true,
  "resumePending": false
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://stripe.com/jobs/search"
        },
        {
            "url": "https://www.notion.com/careers"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/career-page-job-postings-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 = { "startUrls": [
        { "url": "https://stripe.com/jobs/search" },
        { "url": "https://www.notion.com/careers" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/career-page-job-postings-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 '{
  "startUrls": [
    {
      "url": "https://stripe.com/jobs/search"
    },
    {
      "url": "https://www.notion.com/careers"
    }
  ]
}' |
apify call fetch_cat/career-page-job-postings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/career-page-job-postings-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Career Page Job Postings Scraper",
        "description": "Scrape public company career pages and linked ATS job listings into normalized job posting datasets.",
        "version": "0.1",
        "x-build-id": "0LJNQpwbXE6W0DfCe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~career-page-job-postings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-career-page-job-postings-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/fetch_cat~career-page-job-postings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-career-page-job-postings-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/fetch_cat~career-page-job-postings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-career-page-job-postings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Career page URLs",
                        "type": "array",
                        "description": "Public company careers or jobs pages to scan for job postings.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum saved jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many job posting records across all start URLs.",
                        "default": 10
                    },
                    "maxPagesPerSite": {
                        "title": "Maximum pages per site",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum pages to fetch from each career site, including linked public job detail pages.",
                        "default": 10
                    },
                    "includeDetails": {
                        "title": "Fetch job detail pages",
                        "type": "boolean",
                        "description": "Follow public job links to enrich records with description, location, department, salary, and apply URL when available.",
                        "default": true
                    },
                    "keywords": {
                        "title": "Include keywords",
                        "type": "array",
                        "description": "Only save jobs whose title, URL, location, or description contains at least one keyword. Leave empty to include all detected jobs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeKeywords": {
                        "title": "Exclude keywords",
                        "type": "array",
                        "description": "Skip jobs whose title, URL, location, or description contains any of these keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sameDomainOnly": {
                        "title": "Stay on same company domain",
                        "type": "boolean",
                        "description": "When enabled, only follow links on the same domain plus recognized public ATS hosts linked from the career page.",
                        "default": true
                    },
                    "resumePending": {
                        "title": "Resume pending source work",
                        "type": "boolean",
                        "description": "When a previous run saved a PENDING_WORK checkpoint because its time budget ended, continue only those remaining source URLs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
