# Monster Jobs Search Scraper (`soft_alexist/monster-jobs-search-scraper`) Actor

Scrape Monster.com search results to collect job listings at scale. Extract 20+ fields including job IDs, titles, URLs, job types, and enriched metadata — perfect for job aggregators, market research, and recruitment analytics.

- **URL**: https://apify.com/soft\_alexist/monster-jobs-search-scraper.md
- **Developed by:** [Soft Alexist](https://apify.com/soft_alexist) (community)
- **Categories:** Automation, Developer tools, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Monster Jobs Search Scraper: Bulk Extract Job Listings & Data

---

### What Is Monster.com?

Monster.com is one of the world's largest online job boards, hosting millions of active listings across industries, locations, and experience levels. Whether searching for IT roles, healthcare positions, or entry-level jobs, Monster's vast database attracts millions of job seekers monthly. For researchers, aggregators, and recruiters, manually extracting and organizing this data is inefficient — the **Monster Jobs Search Scraper** automates the process, delivering structured job data from search results pages in seconds.

---

### Overview

The **Monster Jobs Search Scraper** extracts job listings from Monster.com search results pages (e.g., "IT Jobs," "Marketing Roles," etc.), converting unstructured HTML into clean, machine-readable records. It is ideal for:

- **Job aggregator platforms** building multi-source job boards
- **Recruitment agencies** tracking market trends and competitor postings
- **Data analysts** studying labor market dynamics and hiring patterns
- **Researchers** analyzing job market supply and demand
- **HR professionals** benchmarking industry salaries and requirements

Key strengths include high-volume scraping (up to 200 items per URL), resilient error handling, and comprehensive enriched metadata across 20+ fields per listing.

---

### Input Format

The scraper accepts a JSON configuration specifying search result pages to extract:

```json
{
  "urls": [
    "https://www.monster.com/jobs/q-it-jobs"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

| Field | Type | Description |
|---|---|---|
| `urls` | Array (strings) | Monster.com search results page URLs. Examples: `q-it-jobs`, `q-marketing-jobs`, location-filtered URLs like `q-it-jobs-in-new-york` |
| `max_items_per_url` | Integer | Maximum job listings to extract per URL (default: `20`, max: `200`). Higher values capture more results but increase run time |
| `ignore_url_failures` | Boolean | If `true`, scraper continues if a URL fails to load (recommended for bulk runs). If `false`, any failure stops the entire process |

> **Tip:** Combine multiple search queries into a single run. Example: `["https://www.monster.com/jobs/q-it-jobs", "https://www.monster.com/jobs/q-sales-jobs"]`

***

### Output Format

**Sample output**

```json
{
  "job_id": "da59d445-28da-480b-bf65-8d68bd14736e",
  "status": "ACTIVE",
  "job_posting": {
    "title": "Junior Production Engineer ( Java / SQL / Automation (AWS)",
    "url": "https://www.monster.com/job-openings/junior-production-engineer-java-sql-automation-aws-alpharetta-ga--da59d445-28da-480b-bf65-8d68bd14736e?mstr_dist=true",
    "date_posted": "2026-04-28T15:12:50.090Z",
    "employment_type": [
      "FULL_TIME",
      "CONTRACTOR",
      "TEMPORARY"
    ],
    "job_location": [
      {
        "@type": "Place",
        "address": {
          "@type": "PostalAddress",
          "address_locality": "Alpharetta",
          "address_region": "GA",
          "address_country": "US"
        },
        "geo": {
          "@type": "GeoCoordinates",
          "latitude": "34.075",
          "longitude": "-84.294"
        }
      }
    ],
    "base_salary": {
      "@type": "MonetaryAmount",
      "currency": "USD",
      "value": {
        "@type": "QuantitativeValue",
        "unit_text": "Per Year"
      }
    },
    "hiring_organization": {
      "name": "VBeyond"
    }
  },
  "canonical_url": "https://www.monster.com/job-openings/junior-production-engineer-java-sql-automation-aws-alpharetta-ga--da59d445-28da-480b-bf65-8d68bd14736e",
  "now": {
    "job_ad_pricing_type_id": 1
  },
  "job_ad": {
    "type": "NoProviderJobAd",
    "provider": "NONE",
    "tracking": {}
  },
  "promoted": false,
  "search_engine": "MCJOBS_ORGANIC",
  "enrichments": {
    "processed_descriptions": {
      "short_description": "The role involves troubleshooting, SQL analysis, automation, and working in AWS environments to ensure stable and scalable services. Job Summary: Hiring a Junior Production Engineer to support and enhance reliability of Java-based production systems."
    },
    "normalized_salary": {
      "currency_code": {
        "name": "USD",
        "id": 920
      },
      "salary_base_type": {
        "name": "YEAR",
        "id": 235
      }
    },
    "employment_types": [
      {
        "name": "TEMPORARY",
        "id": 23
      },
      {
        "name": "FULL_TIME",
        "id": 20
      },
      {
        "name": "CONTRACTOR",
        "id": 22
      }
    ],
    "normalized_job_locations": [
      {
        "postal_address": {
          "@context": "https://schema.org",
          "@type": "Place",
          "address": {
            "@type": "PostalAddress",
            "address_locality": "Alpharetta",
            "address_region": "GA",
            "address_country": "US"
          },
          "geo": {
            "@type": "GeoCoordinates",
            "latitude": "34.075",
            "longitude": "-84.294"
          }
        },
        "location_id": "18442096",
        "country_code": "US"
      }
    ],
    "localized_monster_urls": [
      {
        "location_id": "18442096",
        "url": "https://www.monster.com/job-openings/junior-production-engineer-java-sql-automation-aws-alpharetta-ga--da59d445-28da-480b-bf65-8d68bd14736e"
      }
    ],
    "mescos": [
      {
        "id": "1700194001001"
      },
      {
        "id": "1500142001001"
      },
      {
        "id": "1500127001001"
      }
    ],
    "ingestion_method": {
      "name": "JPW",
      "id": 703
    }
  },
  "field_translations": [
    {
      "field_name": "SalaryBaseType",
      "name": "YEAR",
      "locale": "en-us",
      "translation": "Per Year"
    },
    {
      "field_name": "EmploymentType",
      "name": "TEMPORARY",
      "locale": "en-us",
      "translation": "Temporary"
    },
    {
      "field_name": "EmploymentType",
      "name": "CONTRACTOR",
      "locale": "en-us",
      "translation": "Contractor"
    },
    {
      "field_name": "EmploymentType",
      "name": "FULL_TIME",
      "locale": "en-us",
      "translation": "Full-time"
    }
  ],
  "policy_decisions": {
    "job_location_type_decision": {
      "type": "CLIENT_SPECIFIED",
      "explanation": "Job identified as not remote",
      "result": "ONSITE"
    }
  },
  "normalized_job_posting": {
    "base_salary": {
      "currency": "USD",
      "value": {}
    },
    "salary_currency": "USD"
  },
  "provider": {
    "code": "monster",
    "name": "monster"
  },
  "account_id": "49fac401-9642-4c8d-9651-d2d5e5e5f65a",
  "created_date": "2026-04-28T15:25:59.253Z",
  "modified_date": "2026-07-07T17:53:04.591Z",
  "ingestion_method": "JPW",
  "seo_job_id": "junior-production-engineer-java-sql-automation-aws-alpharetta-ga--da59d445-28da-480b-bf65-8d68bd14736e",
  "date_recency": "30+ days ago",
  "formatted_date": "2026-04-28T00:00:00",
  "job_type": "DURATION",
  "apply": {
    "apply_type": "ONSITE",
    "apply_url": "https://job-openings.monster.com/v2/job/apply?jobid=293378911"
  },
  "from_url": "https://www.monster.com/jobs/q-it-jobs"
}
```

Each extracted job listing returns a comprehensive record with 20 fields:

#### Core Job Identity

| Field | Meaning |
|---|---|
| `Job ID` | Unique identifier for the job posting on Monster |
| `Job Posting` | Full job posting object containing all raw job data |
| `Canonical URL` | Official direct link to the job listing page |
| `Status` | Current status of the listing (e.g., active, filled, expired) |

#### Job Content & Details

| Field | Meaning |
|---|---|
| `Job Ad` | The formatted job advertisement text shown to candidates |
| `Job Type` | Employment contract type (e.g., Full-time, Part-time, Contract, Temporary) |
| `Apply` | Application link or method for submitting a resume |
| `Promoted` | Flag indicating whether the listing has paid promotional boost |

#### Temporal & Recency Data

| Field | Meaning |
|---|---|
| `Now` | Timestamp of when the data was scraped |
| `Created Date` | When the job was first posted to Monster |
| `Modified Date` | Last update timestamp for the listing |
| `Date Recency` | How recently the listing was refreshed (e.g., "Posted 2 days ago") |
| `Formatted Date` | Human-readable version of job posting date |

#### Enriched Metadata & Processing

| Field | Meaning |
|---|---|
| `Enrichments` | AI-extracted structured data (job title normalization, salary ranges, required skills) |
| `Normalized Job Posting` | Standardized version of the job details for consistent analysis |
| `Field Translations` | Localized or translated versions of job fields for multi-regional scrapes |
| `Policy Decisions` | Content moderation flags or policy compliance markers |
| `Search Engine` | Which Monster search index served this result (e.g., primary, mobile) |

#### Provider & Ingestion Info

| Field | Meaning |
|---|---|
| `Provider` | Source system (always "Monster.com" or provider ID) |
| `Account ID` | Monster account or employer ID posting the job |
| `Ingestion Method` | How the data entered the system (e.g., "search\_scrape") |
| `SEO Job ID` | Search engine optimization identifier used in URLs and indexing |

***

### How to Use

1. **Identify search URLs** — Go to Monster.com and perform a job search. Copy the results page URL (e.g., `https://www.monster.com/jobs/q-it-jobs`). You can filter by location, salary, or keywords — the URL updates accordingly.

2. **Build your configuration** — Add one or more search URLs to the `urls` array. Set `max_items_per_url` based on your needs (20 = quick preview, 200 = comprehensive dataset).

3. **Enable error handling** — Set `ignore_url_failures: true` for large runs to avoid interruptions if a page fails to load.

4. **Run the scraper** — Execute and monitor the progress dashboard. The scraper navigates to each URL and extracts all visible listings.

5. **Export & analyze** — Download results as JSON, CSV, or Excel. Use enriched fields for salary analysis, skill matching, or market trend reporting.

**Best practices:**

- Start with `max_items_per_url: 50` to test your URLs before scaling to 200
- Combine related searches into one run (e.g., "IT Jobs" + "DevOps Jobs" + "Cloud Jobs")
- Use the `Enrichments` field for downstream analysis — it contains parsed skills, salaries, and seniority levels

**Troubleshooting:**

- If no results appear, verify the URL is a Monster search results page, not a homepage
- Monster may rate-limit high-volume requests; consider spreading runs across time if scraping 200+ items per URL

***

### Use Cases & Business Value

- **Job boards & aggregators:** Feed multiple job sources into a single platform for job seekers
- **Market research:** Analyze hiring volume, salary trends, and in-demand skills across industries
- **Competitive intelligence:** Track which employers are hiring, in which roles, and with what requirements
- **Recruitment pipeline:** Build prospect lists for recruiters targeting specific job markets
- **Academic studies:** Study labor market evolution, wage trends, and skill demand over time

The Monster Jobs Search Scraper transforms raw search results into actionable datasets, enabling insights at scale that manual browsing cannot achieve.

***

### Conclusion

The **Monster Jobs Search Scraper** is a powerful tool for anyone needing structured job market data from one of the world's largest employment platforms. With support for high-volume extraction, enriched metadata, and flexible search configuration, it enables data-driven recruitment, market analysis, and competitive intelligence. Start scraping today and unlock insights from millions of active job postings.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the Jobs list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.monster.com/jobs/q-it-jobs"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.monster.com/jobs/q-it-jobs"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("soft_alexist/monster-jobs-search-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 = {
    "urls": ["https://www.monster.com/jobs/q-it-jobs"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("soft_alexist/monster-jobs-search-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 '{
  "urls": [
    "https://www.monster.com/jobs/q-it-jobs"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call soft_alexist/monster-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Monster Jobs Search Scraper",
        "description": "Scrape Monster.com search results to collect job listings at scale. Extract 20+ fields including job IDs, titles, URLs, job types, and enriched metadata — perfect for job aggregators, market research, and recruitment analytics.",
        "version": "0.0",
        "x-build-id": "Cb7wLabDW8qlLeAp8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/soft_alexist~monster-jobs-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-soft_alexist-monster-jobs-search-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/soft_alexist~monster-jobs-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-soft_alexist-monster-jobs-search-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/soft_alexist~monster-jobs-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-soft_alexist-monster-jobs-search-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": {
                    "urls": {
                        "title": "URLs of the Jobs list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the Jobs list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
