# Upwork Jobs Scraper — Freelance Job Listings & Client Data (`junipr/upwork-jobs`) Actor

Scrape Upwork job listings by keyword, category, and filters. Extract job descriptions, budgets, client ratings, hire history, required skills, and experience levels.

- **URL**: https://apify.com/junipr/upwork-jobs.md
- **Developed by:** [junipr](https://apify.com/junipr) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$3.90 / 1,000 job scrapeds

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

## Upwork Jobs Scraper

Scrape Upwork job listings by keyword, category, skill, budget range, experience level, client rating, and more. Returns structured data including titles, full descriptions, required skills, budget details, client hire history, proposal counts, and direct job URLs. Built to actually work — unlike the existing 1.3-star actors on Apify Store.

### Why Use This Actor

The current Upwork scrapers on Apify Store have a 1.3-star rating because they fail silently, return empty datasets, and ignore filter inputs entirely. This actor uses Playwright for full browser rendering (required because Upwork is a React SPA), residential proxies to avoid Upwork's aggressive datacenter IP blocking, and exhaustive error handling so you always know what happened. Every filter input actually works, every error produces a clear message, and zero-config runs return real results.

### How to Use

1. Provide a search query (e.g., "python developer", "logo design") or leave the default "web development" for an instant test run.
2. Optionally add filters: job type (hourly/fixed), experience level, budget range, client rating, required skills, or client country.
3. Set `maxJobs` to control how many listings to extract (default: 50, max: 1,000).
4. Enable `includeDescription` to fetch full job descriptions from each job's detail page.
5. Enable `includeClientHistory` to get client spend totals, hire counts, and ratings.
6. Run the actor. Results are pushed to the dataset as structured JSON.

Residential proxy is required and enabled by default on paid Apify plans. Free-plan users must provide their own residential proxy URL.

### Input Configuration

Common setups for different use cases:

- **Freelancer prospecting:** Set `searchQuery` to your skill, `postedWithinDays: 1` for fresh leads, `clientRating: 4` to filter out risky clients.
- **Market research:** Set `categoryId` to a specific category, `maxJobs: 200`, `includeClientHistory: true` to analyze spending patterns.
- **Budget analysis:** Set `jobType: "fixed"`, `minBudget: 500`, `maxBudget: 5000` to study pricing for fixed-price projects.
- **Skill demand tracking:** Set `skills: ["React", "TypeScript"]` to find jobs requiring specific technologies.

All parameters have sensible defaults. The actor works with zero configuration.

### Output Format

Each job listing is returned as a JSON object with the following fields: `jobId`, `title`, `url`, `description`, `descriptionSnippet`, `postedAt`, `jobType`, `experienceLevel`, `budget` (with type, min, max, exact, currency), `skills`, `category`, `subcategory`, `proposalsCount`, `proposalRange`, `client` (with country, rating, reviewCount, totalSpent, totalHires, memberSince, paymentVerified), `duration`, `weeklyHoursRange`, `contractorPreference`, and `scrapedAt`.

A run summary is saved to the key-value store with aggregate stats: total jobs found and scraped, top skills by frequency, average budget, job type breakdown (hourly vs fixed), and total run duration.

### Tips and Advanced Usage

- Use `postedWithinDays: 1` for the freshest leads — schedule the actor to run daily for an automated prospecting pipeline.
- Set `clientRating: 4` to filter out clients with poor payment history and low ratings.
- Use `includeClientHistory: true` to prioritize clients who have spent $10K+ on Upwork — these are serious buyers.
- Set `includeDescription: false` for faster runs when you only need listing-level data (title, budget, skills).
- Export results to CSV and import directly into your CRM or lead tracking tool.
- Combine `skills` filter with `experienceLevel: ["expert"]` to find high-value expert-level contracts.
- Use `clientCountry: "US"` to focus on US-based clients who typically have higher budgets.

### Proxy Requirements

Upwork actively blocks datacenter IP ranges. This actor uses Apify residential proxies by default, which requires a paid Apify plan ($49+/month). Free-plan users must supply their own residential proxy URL in the Proxy Configuration input field. Without a residential proxy, the actor will exit with a clear error message explaining next steps. The actor rotates proxy endpoints and browser fingerprints automatically to avoid detection.

### Related Actors

- [Indeed Job Scraper](https://apify.com/junipr/indeed-job-scraper) — Scrape Indeed.com job listings by keyword and location
- [LinkedIn Jobs Scraper](https://apify.com/junipr/linkedin-jobs) — Extract job listings from LinkedIn
- [Glassdoor Scraper](https://apify.com/junipr/glassdoor-scraper) — Scrape company reviews and salary data


### Pricing

This actor uses Pay-Per-Event (PPE) pricing: **$3.90 per 1,000 jobs scraped** ($0.0039 per event).

Pricing includes all platform compute costs — no hidden fees.


### FAQ

#### Why does Upwork block regular proxies?
Upwork uses sophisticated anti-bot detection that fingerprints datacenter IP ranges. Residential proxies route through real ISP connections, which look like normal user traffic. This is why residential proxy is required and not optional.

#### Can I scrape Upwork without a residential proxy?
No. Upwork will block your requests immediately with datacenter proxies. You need either a paid Apify plan (which includes residential proxy) or your own residential proxy URL from a provider like BrightData, Oxylabs, or SmartProxy.

#### What does the proposals count tell me?
The proposals count shows how many freelancers have already applied to a job. Low proposal counts (under 10) mean less competition and a higher chance of winning the contract. Jobs showing "50+" proposals are highly competitive.

#### How often should I run this for fresh job leads?
For active prospecting, run daily with `postedWithinDays: 1`. For market research, weekly runs with `postedWithinDays: 7` provide good trend data. Schedule runs using Apify's built-in scheduler.

#### Can I get jobs from a specific country's clients?
Yes. Use the `clientCountry` input with an ISO country code like "US", "GB", or "AU". The actor filters results to only include jobs posted by clients from that country.

#### Does it get the full job description or just the snippet?
By default (`includeDescription: true`), the actor navigates to each job's detail page to extract the full description. This adds 1-2 seconds per job but gives you the complete text. Set `includeDescription: false` for faster runs with only the search result snippet.

#### What categories are available?
Common Upwork category slugs include: `web-mobile-software-dev`, `design-creative`, `writing`, `admin-support`, `customer-service`, `data-science-analytics`, `engineering-architecture`, `sales-marketing`, `translation`, and `accounting-consulting`. Check Upwork's category pages for the full list.

#### Is scraping Upwork legal?
This actor scrapes publicly visible job listings that do not require a login. However, Upwork's Terms of Service prohibit automated access. Users are responsible for reviewing Upwork's terms and ensuring compliance in their jurisdiction. This actor is intended for research and data collection purposes.

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword search query (e.g. "python developer", "logo design", "copywriting").
## `categoryId` (type: `string`):

Upwork category slug to filter by (e.g. "web-mobile-software-dev", "design-creative", "writing"). Leave empty for all categories.
## `jobType` (type: `string`):

Filter by job payment type.
## `experienceLevel` (type: `array`):

Filter by required experience level. Select one or more levels. Valid values: entry, intermediate, expert
## `minBudget` (type: `integer`):

Minimum budget in USD for fixed-price jobs.
## `maxBudget` (type: `integer`):

Maximum budget in USD for fixed-price jobs. 0 means no limit.
## `minHourlyRate` (type: `integer`):

Minimum hourly rate in USD for hourly jobs.
## `maxHourlyRate` (type: `integer`):

Maximum hourly rate in USD for hourly jobs. 0 means no limit.
## `clientRating` (type: `number`):

Minimum client rating (1-5). Only return jobs from clients with at least this rating. 0 means no filter.
## `clientCountry` (type: `string`):

Filter by client country using ISO 3166-1 alpha-2 code (e.g. "US", "GB", "AU"). Leave empty for all countries.
## `postedWithinDays` (type: `integer`):

Only return jobs posted within the last N days.
## `skills` (type: `array`):

Filter by required skills (e.g. ["React", "TypeScript"]). Jobs must list ALL specified skills.
## `maxJobs` (type: `integer`):

Maximum number of job listings to return.
## `includeDescription` (type: `boolean`):

Fetch and include the full job description from each job's detail page. Set to false for faster, lightweight listing data only.
## `includeClientHistory` (type: `boolean`):

Include client hire history, payment totals, and rating for each job listing.
## `proxyConfiguration` (type: `object`):

Residential proxy is required — Upwork blocks datacenter IPs. Defaults to Apify residential proxy (requires paid Apify plan). Free-plan users can provide their own residential proxy URL.

## Actor input object example

```json
{
  "searchQuery": "web development",
  "categoryId": "",
  "jobType": "all",
  "experienceLevel": [],
  "minBudget": 0,
  "maxBudget": 0,
  "minHourlyRate": 0,
  "maxHourlyRate": 0,
  "clientRating": 0,
  "clientCountry": "",
  "postedWithinDays": 30,
  "skills": [],
  "maxJobs": 50,
  "includeDescription": true,
  "includeClientHistory": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
````

# Actor output Schema

## `results` (type: `string`):

Scraped Upwork job listings with full job details, client history, and metadata.

# 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 = {
    "searchQuery": "web development"
};

// Run the Actor and wait for it to finish
const run = await client.actor("junipr/upwork-jobs").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 = { "searchQuery": "web development" }

# Run the Actor and wait for it to finish
run = client.actor("junipr/upwork-jobs").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 '{
  "searchQuery": "web development"
}' |
apify call junipr/upwork-jobs --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Upwork Jobs Scraper — Freelance Job Listings & Client Data",
        "description": "Scrape Upwork job listings by keyword, category, and filters. Extract job descriptions, budgets, client ratings, hire history, required skills, and experience levels.",
        "version": "1.0",
        "x-build-id": "wbnuTtZbikxVCNfbY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/junipr~upwork-jobs/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-junipr-upwork-jobs",
                "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/junipr~upwork-jobs/runs": {
            "post": {
                "operationId": "runs-sync-junipr-upwork-jobs",
                "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/junipr~upwork-jobs/run-sync": {
            "post": {
                "operationId": "run-sync-junipr-upwork-jobs",
                "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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword search query (e.g. \"python developer\", \"logo design\", \"copywriting\").",
                        "default": "web development"
                    },
                    "categoryId": {
                        "title": "Category",
                        "type": "string",
                        "description": "Upwork category slug to filter by (e.g. \"web-mobile-software-dev\", \"design-creative\", \"writing\"). Leave empty for all categories.",
                        "default": ""
                    },
                    "jobType": {
                        "title": "Job Type",
                        "enum": [
                            "all",
                            "hourly",
                            "fixed"
                        ],
                        "type": "string",
                        "description": "Filter by job payment type.",
                        "default": "all"
                    },
                    "experienceLevel": {
                        "title": "Experience Level",
                        "type": "array",
                        "description": "Filter by required experience level. Select one or more levels. Valid values: entry, intermediate, expert",
                        "items": {
                            "type": "string",
                            "enum": [
                                "entry",
                                "intermediate",
                                "expert"
                            ],
                            "enumTitles": [
                                "Entry level",
                                "Intermediate",
                                "Expert"
                            ]
                        },
                        "default": []
                    },
                    "minBudget": {
                        "title": "Min Budget (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum budget in USD for fixed-price jobs.",
                        "default": 0
                    },
                    "maxBudget": {
                        "title": "Max Budget (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum budget in USD for fixed-price jobs. 0 means no limit.",
                        "default": 0
                    },
                    "minHourlyRate": {
                        "title": "Min Hourly Rate (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum hourly rate in USD for hourly jobs.",
                        "default": 0
                    },
                    "maxHourlyRate": {
                        "title": "Max Hourly Rate (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum hourly rate in USD for hourly jobs. 0 means no limit.",
                        "default": 0
                    },
                    "clientRating": {
                        "title": "Min Client Rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Minimum client rating (1-5). Only return jobs from clients with at least this rating. 0 means no filter.",
                        "default": 0
                    },
                    "clientCountry": {
                        "title": "Client Country",
                        "type": "string",
                        "description": "Filter by client country using ISO 3166-1 alpha-2 code (e.g. \"US\", \"GB\", \"AU\"). Leave empty for all countries.",
                        "default": ""
                    },
                    "postedWithinDays": {
                        "title": "Posted Within (days)",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Only return jobs posted within the last N days.",
                        "default": 30
                    },
                    "skills": {
                        "title": "Required Skills",
                        "type": "array",
                        "description": "Filter by required skills (e.g. [\"React\", \"TypeScript\"]). Jobs must list ALL specified skills.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxJobs": {
                        "title": "Max Jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job listings to return.",
                        "default": 50
                    },
                    "includeDescription": {
                        "title": "Include Full Description",
                        "type": "boolean",
                        "description": "Fetch and include the full job description from each job's detail page. Set to false for faster, lightweight listing data only.",
                        "default": true
                    },
                    "includeClientHistory": {
                        "title": "Include Client History",
                        "type": "boolean",
                        "description": "Include client hire history, payment totals, and rating for each job listing.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxy is required — Upwork blocks datacenter IPs. Defaults to Apify residential proxy (requires paid Apify plan). Free-plan users can provide their own residential proxy URL.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```