# SmartRecruiters Jobs Scraper (`fetch_cat/smartrecruiters-jobs-scraper`) Actor

Scrape public SmartRecruiters job postings by company with details and apply URLs.

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

## Pricing

from $0.03 / 1,000 result extracteds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## SmartRecruiters Jobs Scraper

Collect public job postings from SmartRecruiters-powered career pages.

Use this actor when you need structured hiring data from companies that publish roles through SmartRecruiters. Provide company names or career page URLs, choose how many jobs you want, and export clean records with titles, locations, departments, job links, apply links, descriptions, and posting dates.

### What does SmartRecruiters Jobs Scraper do?

SmartRecruiters Jobs Scraper turns public SmartRecruiters career pages into a structured dataset.

It helps you:

- 🧲 Monitor open roles at target companies
- 📈 Track hiring trends by department, location, and remote status
- 🧾 Export job descriptions for analysis
- 🔎 Build recruiting, sales, or labor-market workflows
- 🔗 Collect public job and apply links in one table

### Who is it for?

This actor is useful for several teams.

- Recruiters tracking competitor hiring
- Sales teams looking for buying signals
- Labor-market analysts monitoring demand
- Job-board operators collecting public roles
- RevOps teams enriching account research
- Founders watching where companies are investing

### Why use it?

SmartRecruiters career pages are common across enterprise hiring teams. Manually checking every company page is slow and easy to forget.

This actor gives you repeatable exports that can run on a schedule, feed a CRM, power a job board, or support market research.

### Typical use cases

- Track new jobs at a list of target accounts
- Watch which departments are growing
- Find companies hiring for a specific role family
- Export remote roles for a job-alert workflow
- Build datasets for hiring trend dashboards
- Enrich company profiles with current open roles

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

The actor uses pay-per-event pricing.

You pay a small run start fee and then a per-job fee for each saved job posting.

A small test run with 25 jobs is inexpensive. Larger runs scale with the number of jobs saved, so you can control spend with the **Maximum jobs** input.

### Input options

You can provide company names, career page URLs, or both.

| Input | Type | Description |
| --- | --- | --- |
| `companyIdentifiers` | array | SmartRecruiters company slugs such as `SmartRecruiters` |
| `companyUrls` | array | SmartRecruiters career page URLs |
| `limit` | integer | Maximum jobs to save across all companies |
| `includeDetails` | boolean | Include descriptions and apply links when available |
| `maxConcurrency` | integer | Number of parallel detail requests |

### Example input

```json
{
  "companyIdentifiers": ["SmartRecruiters"],
  "limit": 25,
  "includeDetails": true,
  "maxConcurrency": 5
}
````

### Company names and URLs

The simplest input is a SmartRecruiters company slug.

For example, if the public career page is:

```text
https://jobs.smartrecruiters.com/SmartRecruiters
```

Use:

```json
{
  "companyIdentifiers": ["SmartRecruiters"]
}
```

You can also paste the career page URL into `companyUrls`.

### Output data

Each dataset row is one public job posting.

| Field | Description |
| --- | --- |
| `jobId` | SmartRecruiters job identifier |
| `refNumber` | Employer reference / requisition number |
| `title` | Job title |
| `company` | Company name |
| `department` | Department when available |
| `function` | Job function when available |
| `location` | Full location string |
| `remote` | Remote-work flag when available |
| `hybrid` | Hybrid-work flag when available |
| `employmentType` | Employment type when available |
| `experienceLevel` | Experience level when available |
| `language` | Job ad language when available |
| `postedDate` | Public posting date |
| `applyUrl` | Apply link |
| `jobUrl` | Public job page link |
| `descriptionText` | Plain-text job description |
| `descriptionHtml` | HTML job description |
| `sourceCompanySlug` | Company slug used for the scrape |
| `scrapedAt` | Timestamp when the job was saved |

### Example output item

```json
{
  "jobId": "744000132998500",
  "refNumber": "REF2010Z",
  "title": "Senior Information Security Specialist",
  "company": "SmartRecruiters Inc",
  "department": "Engineering",
  "function": "Engineering",
  "location": "Poland, REMOTE, Poland",
  "remote": true,
  "hybrid": false,
  "employmentType": "Full-time",
  "experienceLevel": "Mid-Senior Level",
  "language": "English",
  "postedDate": "2026-06-19T06:46:31.452Z",
  "applyUrl": "https://jobs.smartrecruiters.com/smartrecruiters/...",
  "jobUrl": "https://jobs.smartrecruiters.com/smartrecruiters/...",
  "descriptionText": "SmartRecruiters is looking for...",
  "descriptionHtml": "<p>SmartRecruiters is looking for...</p>",
  "sourceCompanySlug": "SmartRecruiters",
  "scrapedAt": "2026-06-23T14:30:00.000Z"
}
```

### How to run it

1. Open the actor on Apify.
2. Add one or more SmartRecruiters company names or career URLs.
3. Set **Maximum jobs** to the number of postings you want.
4. Keep **Include job descriptions** enabled if you need full job text.
5. Click **Start**.
6. Export the dataset as JSON, CSV, Excel, or via API.

### Tips for best results

- Start with one company and a small limit to confirm the slug.
- Use company URLs if you are unsure about the exact slug.
- Increase the limit for scheduled monitoring runs.
- Keep descriptions enabled for analysis workflows.
- Disable descriptions when you only need a fast list of titles and URLs.

### Scheduling

You can run this actor on a schedule.

Common schedules include:

- Daily checks for new jobs
- Weekly hiring trend snapshots
- Monthly account enrichment exports

Scheduled runs are useful when you want to detect new openings without manually checking career pages.

### Integrations

The dataset can be sent to many tools.

- Google Sheets for lightweight monitoring
- Airtable for recruiting operations
- CRM systems for sales triggers
- BI dashboards for hiring analytics
- Webhooks for alerts when new jobs appear
- Data warehouses for trend analysis

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/smartrecruiters-jobs-scraper').call({
  companyIdentifiers: ['SmartRecruiters'],
  limit: 25,
  includeDetails: true
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/smartrecruiters-jobs-scraper').call(run_input={
    'companyIdentifiers': ['SmartRecruiters'],
    'limit': 25,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~smartrecruiters-jobs-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"companyIdentifiers":["SmartRecruiters"],"limit":25,"includeDetails":true}'
```

### MCP usage

Use Apify MCP to run this actor from AI tools.

MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/smartrecruiters-jobs-scraper
```

Claude Code setup:

```bash
claude mcp add apify-smartrecruiters-jobs "https://mcp.apify.com/?tools=fetch_cat/smartrecruiters-jobs-scraper"
```

JSON MCP server configuration:

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

Example prompts:

- "Run SmartRecruiters Jobs Scraper for SmartRecruiters and summarize open engineering roles."
- "Find remote jobs from this SmartRecruiters company page and export them as a table."
- "Compare current job postings with last week's dataset and list new roles."

### Data freshness

The actor reads public career page data at run time. Each item includes `scrapedAt`, so you can compare exports over time.

### Limits

The actor can save up to the limit you set. If a company has fewer public jobs than your limit, the run finishes after collecting all available jobs.

### Empty results

An empty dataset usually means one of these things:

- The company slug is misspelled
- The company is not hosted on SmartRecruiters
- The company currently has no public jobs
- The career page URL is not a SmartRecruiters URL

Try pasting the full company career URL if the slug is unclear.

### Troubleshooting

#### Why did I get fewer jobs than my limit?

The company may have fewer public postings than your requested maximum. The limit is a cap, not a guarantee.

#### Why is a field empty?

Not every company fills every SmartRecruiters field. Department, employment type, remote status, and descriptions depend on what the company publishes.

#### Can I scrape private or internal jobs?

No. This actor is designed for public job postings only.

### Legality

This actor collects publicly available job posting data. You are responsible for using the data legally and respecting applicable laws, terms, and privacy rules. Do not use it to collect private, internal, or access-restricted content.

### Related scrapers

You may also find these useful:

- https://apify.com/fetch\_cat/greenhouse-jobs-scraper
- https://apify.com/fetch\_cat/lever-jobs-scraper
- https://apify.com/fetch\_cat/ashby-jobs-scraper
- https://apify.com/fetch\_cat/workday-jobs-scraper

### FAQ

#### Does this actor need my SmartRecruiters login?

No. It only collects public job postings.

#### Can I run multiple companies at once?

Yes. Add multiple values to `companyIdentifiers` or `companyUrls`.

#### Can I export to CSV?

Yes. Apify datasets can be exported as CSV, JSON, Excel, XML, RSS, and more.

#### Can I monitor new jobs over time?

Yes. Schedule the actor and compare datasets by `jobId` and `scrapedAt`.

#### Does it include apply links?

Yes, when available from the public posting data.

#### Does it include full descriptions?

Yes, keep `includeDetails` enabled to save `descriptionText` and `descriptionHtml`.

### Changelog

#### 0.1

Initial version for public SmartRecruiters job postings.

# Actor input Schema

## `companyIdentifiers` (type: `array`):

SmartRecruiters company identifiers, for example `SmartRecruiters`, `Bosch`, or `Wolt`. Use the slug from the company's SmartRecruiters career URL.

## `companyUrls` (type: `array`):

Optional SmartRecruiters career page or API URLs. Examples: `https://jobs.smartrecruiters.com/SmartRecruiters` or `https://api.smartrecruiters.com/v1/companies/SmartRecruiters/postings`.

## `limit` (type: `integer`):

Maximum number of job postings to save across all companies.

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

Fetch each public posting detail record to include apply URLs and description HTML/text. Disable for faster list-only runs.

## `maxConcurrency` (type: `integer`):

Maximum number of concurrent detail API requests.

## Actor input object example

```json
{
  "companyIdentifiers": [
    "SmartRecruiters"
  ],
  "companyUrls": [],
  "limit": 20,
  "includeDetails": true,
  "maxConcurrency": 5
}
```

# 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 = {
    "companyIdentifiers": [
        "SmartRecruiters"
    ],
    "companyUrls": [],
    "limit": 20,
    "includeDetails": true,
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/smartrecruiters-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 = {
    "companyIdentifiers": ["SmartRecruiters"],
    "companyUrls": [],
    "limit": 20,
    "includeDetails": True,
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/smartrecruiters-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 '{
  "companyIdentifiers": [
    "SmartRecruiters"
  ],
  "companyUrls": [],
  "limit": 20,
  "includeDetails": true,
  "maxConcurrency": 5
}' |
apify call fetch_cat/smartrecruiters-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SmartRecruiters Jobs Scraper",
        "description": "Scrape public SmartRecruiters job postings by company with details and apply URLs.",
        "version": "0.1",
        "x-build-id": "AFqljtB4s8zgMYro6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~smartrecruiters-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-smartrecruiters-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/fetch_cat~smartrecruiters-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-smartrecruiters-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/fetch_cat~smartrecruiters-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-smartrecruiters-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": {
                    "companyIdentifiers": {
                        "title": "Company identifiers / slugs",
                        "type": "array",
                        "description": "SmartRecruiters company identifiers, for example `SmartRecruiters`, `Bosch`, or `Wolt`. Use the slug from the company's SmartRecruiters career URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyUrls": {
                        "title": "Company career URLs",
                        "type": "array",
                        "description": "Optional SmartRecruiters career page or API URLs. Examples: `https://jobs.smartrecruiters.com/SmartRecruiters` or `https://api.smartrecruiters.com/v1/companies/SmartRecruiters/postings`.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "limit": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of job postings to save across all companies.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Include job descriptions",
                        "type": "boolean",
                        "description": "Fetch each public posting detail record to include apply URLs and description HTML/text. Disable for faster list-only runs.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of concurrent detail API requests.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```