# Upwork Jobs Scraper - $0.5 per 1k (`curious_coder/upwork-jobs-scraper`) Actor

Scrape job listings from Upwork search results by URL or filters. Export titles, descriptions, budgets, skills, experience level and more to JSON, CSV or Excel.

- **URL**: https://apify.com/curious\_coder/upwork-jobs-scraper.md
- **Developed by:** [Curious Coder](https://apify.com/curious_coder) (community)
- **Categories:** Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Job Scraper

Collect job listings from [Upwork](https://www.upwork.com) search results — no login, no manual copy‑pasting. Give it an Upwork search URL or pick a few filters, and the scraper returns clean, structured job data ready to export as **JSON, CSV, or Excel**.

Great for freelancers tracking new opportunities, agencies building lead lists, and analysts researching the freelance market.

### What you can do

- 🔎 Scrape jobs from **any Upwork search** — just paste the search URL from your browser.
- 🎛️ Or build a search right here using **simple filters** (keyword, budget, experience level, and more).
- 📄 Get the full **job details**: title, description, budget, required skills, experience level, and post date.
- 🔗 Get a **direct link** to every job.
- 📊 Export to **JSON, CSV, Excel**, or push the data to your own apps.
- 🔁 Run it **on a schedule** to catch new jobs automatically.

### How to use it

1. Click **Try for free**.
2. Either:
   - paste one or more **Upwork search URLs** into *Search URLs*, **or**
   - type a **keyword** and choose any **filters** you want.
3. Set **Max jobs** (how many results to collect).
4. Click **Start** and download your results when the run finishes.

#### Getting a search URL (easiest method)

1. Go to [upwork.com/nx/search/jobs](https://www.upwork.com/nx/search/jobs/) and search as you normally would.
2. Apply any filters you like (job type, budget, experience level, client location…).
3. Copy the full address from your browser's address bar and paste it into **Search URLs**.

Every filter you set on Upwork is kept in that URL, so the scraper returns exactly what you see on the site.

### Input

You can use **search URLs**, **filters**, or both. Filters are only needed if you don't provide a URL.

| Field | Description |
| --- | --- |
| **Search URLs** | One or more Upwork job‑search URLs copied from your browser. |
| **Search keyword** | Free‑text keyword (e.g. `react native`, `logo design`). |
| **Sort by** | Most recent or most relevant. |
| **Job type** | Hourly, fixed price, or weekly retainer. |
| **Experience level** | Entry level, intermediate, or expert. |
| **Hourly rate range** | Client's hourly budget, e.g. `10-50` (or `20-` for $20+). |
| **Fixed‑price budget** | Budget brackets, e.g. under $100 up to $5,000+. |
| **Client hires** | Filter by how many people the client has hired before. |
| **Client location(s)** | Regions or countries, e.g. `Americas`, `Oceania`. |
| **Project duration** | Less than a month up to 6+ months. |
| **Workload** | As needed, part time, or full time. |
| **Contract‑to‑hire only** | Only show contract‑to‑hire roles. |
| **Payment‑verified clients only** | Only show jobs from payment‑verified clients. |
| **Max jobs** | How many jobs to collect (0 = as many as available). |

#### Example input

```json
{
  "startUrls": [
    "https://www.upwork.com/nx/search/jobs/?q=full%20stack&sort=recency&t=0,1&contractor_tier=2,3"
  ],
  "maxItems": 100
}
````

Or with filters instead of a URL:

```json
{
  "searchQuery": "react native",
  "jobType": ["1"],
  "experienceLevel": ["3"],
  "fixedBudget": ["500-999", "1000-4999"],
  "sort": "recency",
  "maxItems": 50
}
```

### Output

Each job is saved as one record. Example:

```json
{
  "id": "2070162917228783082",
  "url": "https://www.upwork.com/jobs/~022070162917228783082",
  "title": "React TypeScript Developer / Full Stack Web App",
  "description": "We're looking for an experienced developer to build…",
  "jobType": "FIXED",
  "contractorTier": "ExpertLevel",
  "hourly": null,
  "fixedPrice": { "amount": "1360.0", "currency": "USD", "duration": "Less than 1 month" },
  "skills": ["React", "TypeScript", "Node.js", "Web Development"],
  "publishTime": "2026-06-25T15:14:18.014Z",
  "createTime": "2026-06-25T15:11:16.284Z",
  "searchUrl": "https://www.upwork.com/nx/search/jobs/?q=full%20stack&sort=recency",
  "scrapedAt": "2026-06-25T15:33:35.349Z"
}
```

| Field | Description |
| --- | --- |
| `title` | Job title |
| `url` | Direct link to the job on Upwork |
| `description` | Full job description |
| `jobType` | `HOURLY`, `FIXED`, or weekly retainer |
| `contractorTier` | Experience level required (Entry / Intermediate / Expert) |
| `hourly` | Hourly budget range, engagement type, and duration (for hourly jobs) |
| `fixedPrice` | Amount, currency, and duration (for fixed‑price jobs) |
| `skills` | Skills requested for the job |
| `publishTime` / `createTime` | When the job was posted |
| `searchUrl` | The search this job came from |
| `scrapedAt` | When the record was collected |

### Tips

- **Get more results per keyword** by sorting by *Most recent* and running on a schedule, so you keep catching newly posted jobs.
- **Combine searches** by adding several URLs at once — all results land in the same dataset.
- **Export anywhere** — download as Excel/CSV/JSON from the run, or connect the dataset to Make, Zapier, Google Sheets, and more.

### FAQ

**Do I need an Upwork account?** No. The scraper reads publicly visible job listings.

**Will it return every matching job?** It collects up to **Max jobs**, within the number of results Upwork makes available for a search. Narrow your filters to focus on the most relevant jobs.

**Is scraping Upwork allowed?** Only collect publicly available data and use it responsibly, in line with Upwork's terms and applicable laws.

# Actor input Schema

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

Full Upwork job-search URLs copied from the browser address bar (e.g. https://www.upwork.com/nx/search/jobs/?q=full%20stack\&sort=recency\&t=0,1). All on-site filters in the URL are honored.

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

Free-text keyword to search jobs for (used when no Search URL is given).

## `sort` (type: `string`):

Result ordering.

## `jobType` (type: `array`):

Hourly and/or fixed-price jobs.

## `experienceLevel` (type: `array`):

Freelancer experience level required by the client.

## `hourlyRate` (type: `string`):

Client hourly budget range, formatted as 'min-max' (e.g. '10-50', or '20-' for 20+). Hourly jobs only.

## `fixedBudget` (type: `array`):

Fixed-price budget buckets.

## `clientHires` (type: `array`):

Number of people the client has previously hired.

## `location` (type: `array`):

Client locations/regions (e.g. 'Americas', 'Oceania', or a country name exactly as Upwork uses it).

## `projectDuration` (type: `array`):

Expected project length.

## `workload` (type: `array`):

Hours-per-week commitment.

## `contractToHire` (type: `boolean`):

Only return contract-to-hire jobs.

## `paymentVerified` (type: `boolean`):

Only return jobs from payment-verified clients.

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

Maximum number of jobs to collect across all searches. Set to 0 to collect as many as Upwork makes available.

## `filtersJson` (type: `object`):

Optional. Add any additional Upwork filters as key/value pairs, e.g. { "category2\_uid": \["531770282584862721"] }. Most users can leave this empty.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.upwork.com/nx/search/jobs/?q=react&contractor_tier=2,3"
  ],
  "sort": "recency",
  "jobType": [],
  "experienceLevel": [],
  "fixedBudget": [],
  "clientHires": [],
  "location": [],
  "projectDuration": [],
  "workload": [],
  "contractToHire": false,
  "paymentVerified": false,
  "maxItems": 100
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.upwork.com/nx/search/jobs/?q=full%20stack&sort=recency&t=0,1"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("curious_coder/upwork-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 = { "startUrls": ["https://www.upwork.com/nx/search/jobs/?q=full%20stack&sort=recency&t=0,1"] }

# Run the Actor and wait for it to finish
run = client.actor("curious_coder/upwork-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 '{
  "startUrls": [
    "https://www.upwork.com/nx/search/jobs/?q=full%20stack&sort=recency&t=0,1"
  ]
}' |
apify call curious_coder/upwork-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Upwork Jobs Scraper - $0.5 per 1k",
        "description": "Scrape job listings from Upwork search results by URL or filters. Export titles, descriptions, budgets, skills, experience level and more to JSON, CSV or Excel.",
        "version": "1.0",
        "x-build-id": "mFqubgxMh1MyoQdXw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/curious_coder~upwork-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-curious_coder-upwork-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/curious_coder~upwork-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-curious_coder-upwork-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/curious_coder~upwork-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-curious_coder-upwork-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": {
                    "startUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Full Upwork job-search URLs copied from the browser address bar (e.g. https://www.upwork.com/nx/search/jobs/?q=full%20stack&sort=recency&t=0,1). All on-site filters in the URL are honored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Free-text keyword to search jobs for (used when no Search URL is given)."
                    },
                    "sort": {
                        "title": "Sort by",
                        "enum": [
                            "recency",
                            "relevance+desc"
                        ],
                        "type": "string",
                        "description": "Result ordering.",
                        "default": "recency"
                    },
                    "jobType": {
                        "title": "Job type",
                        "type": "array",
                        "description": "Hourly and/or fixed-price jobs.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "0",
                                "1",
                                "2"
                            ],
                            "enumTitles": [
                                "Hourly",
                                "Fixed price",
                                "Weekly retainer"
                            ]
                        },
                        "default": []
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "type": "array",
                        "description": "Freelancer experience level required by the client.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3"
                            ],
                            "enumTitles": [
                                "Entry level",
                                "Intermediate",
                                "Expert"
                            ]
                        },
                        "default": []
                    },
                    "hourlyRate": {
                        "title": "Hourly rate range",
                        "type": "string",
                        "description": "Client hourly budget range, formatted as 'min-max' (e.g. '10-50', or '20-' for 20+). Hourly jobs only."
                    },
                    "fixedBudget": {
                        "title": "Fixed-price budget",
                        "type": "array",
                        "description": "Fixed-price budget buckets.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "0-99",
                                "100-499",
                                "500-999",
                                "1000-4999",
                                "5000-"
                            ],
                            "enumTitles": [
                                "< $100",
                                "$100–$499",
                                "$500–$999",
                                "$1,000–$4,999",
                                "$5,000+"
                            ]
                        },
                        "default": []
                    },
                    "clientHires": {
                        "title": "Client hires",
                        "type": "array",
                        "description": "Number of people the client has previously hired.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "0",
                                "1-9",
                                "10-"
                            ],
                            "enumTitles": [
                                "No hires",
                                "1–9 hires",
                                "10+ hires"
                            ]
                        },
                        "default": []
                    },
                    "location": {
                        "title": "Client location(s)",
                        "type": "array",
                        "description": "Client locations/regions (e.g. 'Americas', 'Oceania', or a country name exactly as Upwork uses it).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "projectDuration": {
                        "title": "Project duration",
                        "type": "array",
                        "description": "Expected project length.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "week",
                                "month",
                                "semester",
                                "ongoing"
                            ],
                            "enumTitles": [
                                "< 1 month",
                                "1–3 months",
                                "3–6 months",
                                "6+ months"
                            ]
                        },
                        "default": []
                    },
                    "workload": {
                        "title": "Workload",
                        "type": "array",
                        "description": "Hours-per-week commitment.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "as_needed",
                                "part_time",
                                "full_time"
                            ],
                            "enumTitles": [
                                "As needed",
                                "Part time (<30 hrs/wk)",
                                "Full time (30+ hrs/wk)"
                            ]
                        },
                        "default": []
                    },
                    "contractToHire": {
                        "title": "Contract-to-hire only",
                        "type": "boolean",
                        "description": "Only return contract-to-hire jobs.",
                        "default": false
                    },
                    "paymentVerified": {
                        "title": "Payment-verified clients only",
                        "type": "boolean",
                        "description": "Only return jobs from payment-verified clients.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max jobs",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of jobs to collect across all searches. Set to 0 to collect as many as Upwork makes available.",
                        "default": 100
                    },
                    "filtersJson": {
                        "title": "Extra filters (advanced)",
                        "type": "object",
                        "description": "Optional. Add any additional Upwork filters as key/value pairs, e.g. { \"category2_uid\": [\"531770282584862721\"] }. Most users can leave this empty."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
