# Upwork Scraper (`kawsar/upwork-scraper`) Actor

Upwork job scraper that pulls live listings with full filter support for job type, budget, experience level, and duration, so recruiters and developers get structured data without manual searching.

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

## Pricing

$49.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 Scraper: Extract Upwork Job Listings with Full Filter Support

Upwork Scraper pulls job listings from Upwork with the same filters you'd set manually: job type, experience level, budget range, duration, and workload. It handles Upwork's JavaScript-heavy pages automatically and returns clean, structured records with job details, required skills, and client data including total spend and hire history.

Use it to monitor new jobs in your niche, research what skills and rates the market is paying, build lead lists, or feed Upwork data into your own tools and dashboards.

### Use cases

- **Lead generation**: spot clients posting jobs in your niche before competitors do
- **Market research**: track skill demand and budget trends across Upwork categories over time
- **Hiring intelligence**: monitor what roles are getting posted and at what rate or budget
- **Competitive analysis**: see how many proposals jobs attract and what experience levels clients want
- **CRM enrichment**: pull structured job and client data into spreadsheets or your own tooling
- **Automated job alerts**: run on a schedule and push new matches to Slack, email, or a webhook

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | required | Keywords to search on Upwork (e.g. "python developer", "react frontend") |
| `jobType` | string | `all` | Payment type: `all`, `hourly`, or `fixed` |
| `experienceLevel` | array | `[]` | One or more of: `entry`, `intermediate`, `expert`. Empty means all. |
| `sortBy` | string | `recency` | Sort order: `recency` or `relevance` |
| `hourlyRateMin` | integer | — | Minimum hourly rate in USD |
| `hourlyRateMax` | integer | — | Maximum hourly rate in USD |
| `budgetMin` | integer | — | Minimum fixed project budget in USD |
| `budgetMax` | integer | — | Maximum fixed project budget in USD |
| `duration` | string | `all` | Project length: `week`, `month`, `semester`, `ongoing`, or `all` |
| `workload` | string | `all` | Weekly hours: `part_time`, `full_time`, or `all` |
| `renderJs` | boolean | `true` | Enable JavaScript rendering. Required for Upwork pages. |
| `maxItems` | integer | `10` | Number of job listings to return. Maximum is 10 (one page). |
| `requestTimeoutSecs` | integer | `60` | Per-request timeout in seconds |
| `timeoutSecs` | integer | `300` | Total actor run timeout in seconds |

#### Example: scrape Python developer jobs (hourly, mid-to-senior level)

```json
{
    "searchQuery": "python developer",
    "jobType": "hourly",
    "experienceLevel": ["intermediate", "expert"],
    "sortBy": "recency",
    "hourlyRateMin": 20,
    "hourlyRateMax": 80
}
````

#### Example: scrape fixed-price React jobs under $2,000

```json
{
    "searchQuery": "react frontend developer",
    "jobType": "fixed",
    "experienceLevel": ["entry", "intermediate"],
    "budgetMin": 100,
    "budgetMax": 2000,
    "sortBy": "recency"
}
```

#### Example: monitor long-term data science contracts

```json
{
    "searchQuery": "data scientist machine learning",
    "jobType": "hourly",
    "experienceLevel": ["expert"],
    "duration": "ongoing",
    "workload": "full_time",
    "sortBy": "relevance"
}
```

#### Example: entry-level writing jobs sorted by recency

```json
{
    "searchQuery": "content writer blog articles",
    "jobType": "all",
    "experienceLevel": ["entry", "intermediate"],
    "sortBy": "recency"
}
```

### Output

The actor stores results in a dataset. Each job listing produces one record:

```json
{
    "jobId": "~01234567abcdef89",
    "jobTitle": "Senior Python Developer for Data Pipeline",
    "jobDescription": "Looking for an experienced Python developer to build an ETL pipeline that moves data from Salesforce into BigQuery on a daily schedule...",
    "skills": ["Python", "Apache Airflow", "PostgreSQL", "Google BigQuery", "AWS"],
    "category": "Web, Mobile & Software Dev",
    "subcategory": "Web Development",
    "jobPaymentType": "hourly",
    "experienceLevel": "Expert",
    "duration": "3 to 6 months",
    "workload": "30+ hrs/week",
    "hourlyRateMin": 30.0,
    "hourlyRateMax": 60.0,
    "fixedBudget": null,
    "budgetText": "$30.00-$60.00/hr",
    "clientCountry": "United States",
    "clientRating": 4.9,
    "clientJobsPosted": 47,
    "clientTotalSpent": 24500.0,
    "clientTotalHires": 12,
    "clientPaymentVerified": true,
    "proposalCount": "10 to 15",
    "connectsRequired": 6,
    "publishedAt": "2025-03-15T10:22:00.000+00:00",
    "postedAgo": "2 hours ago",
    "jobUrl": "https://www.upwork.com/jobs/~01234567abcdef89",
    "scrapedAt": "2025-03-20T08:45:12.123456+00:00"
}
```

#### Output fields reference

| Field | Type | Description |
|-------|------|-------------|
| `jobId` | string | Upwork job identifier |
| `jobTitle` | string | Job posting title |
| `jobDescription` | string | Job description text |
| `skills` | array | Required skill tags |
| `category` | string | Upwork job category |
| `subcategory` | string | Upwork job subcategory |
| `jobPaymentType` | string | `hourly` or `fixed` |
| `experienceLevel` | string | Entry, Intermediate, or Expert |
| `duration` | string | Expected project duration |
| `workload` | string | Weekly hours commitment (e.g. "30+ hrs/week") |
| `hourlyRateMin` | number | Min hourly rate in USD |
| `hourlyRateMax` | number | Max hourly rate in USD |
| `fixedBudget` | number | Fixed budget in USD |
| `budgetText` | string | Formatted budget or rate (e.g. "$30.00-$60.00/hr") |
| `clientCountry` | string | Client country |
| `clientRating` | number | Client feedback score (0-5) |
| `clientJobsPosted` | integer | Total jobs this client has posted |
| `clientTotalSpent` | number | Total USD spent by this client on Upwork |
| `clientTotalHires` | integer | Total freelancers hired by this client |
| `clientPaymentVerified` | boolean | Whether the client's payment method is verified |
| `proposalCount` | string | Proposal count range (e.g. "10 to 15") |
| `connectsRequired` | integer | Connects needed to apply |
| `publishedAt` | string | ISO 8601 timestamp the job was posted |
| `postedAgo` | string | Relative time since posting (e.g. "2 hours ago") |
| `jobUrl` | string | Direct URL to the job on Upwork |
| `scrapedAt` | string | ISO 8601 timestamp when the record was scraped |

### How it works

1. Builds a search URL from your query and active filters
2. Fetches the page using a rendering engine with residential proxy support
3. Parses job tiles directly from the rendered HTML
4. Transforms each job into a clean record and pushes it to the dataset
5. Returns up to 10 results from the first page of search results

### What data does this actor extract?

For each job listing, the actor extracts the job title, full description, skill tags, category, subcategory, payment type, rate or budget, experience level, project duration, and workload. It also captures client-side data: country, feedback rating, payment verification status, total jobs posted, total amount spent on Upwork, total hires, proposal count, Connects required to apply, and a relative posted time (e.g. "2 hours ago").

### FAQ

**What if some fields come back null?**
Upwork's page structure changes over time. A null field means it was not present on that listing or the parser did not find it in the current layout. The record is still saved with all fields that were successfully extracted.

**How many results can I get per run?**
Up to 10 per run — one page of Upwork search results. Use `maxItems` if you need fewer.

**Can I filter by multiple experience levels at once?**
Yes. Pass an array to `experienceLevel`, for example `["intermediate", "expert"]`, and both filters are applied to the search.

**Can I run this on a schedule?**
Yes. Use Apify's built-in scheduler with a cron expression. Pair it with a webhook to push new results to Slack, Google Sheets, or your CRM automatically after each run.

**What happens if the page fails to load?**
The actor logs the HTTP status code and stops cleanly. Any results already collected are saved to the dataset.

### Integrations

Connect Upwork Scraper with other apps and services using [Apify integrations](https://apify.com/integrations). You can integrate with Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and many more. You can also use [webhooks](https://docs.apify.com/integrations/webhooks) to trigger actions whenever new job results are available.

# Actor input Schema

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

Keywords to search for on Upwork (e.g. 'python developer', 'data analyst', 'react frontend').

## `jobType` (type: `string`):

Filter by job payment type.

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

Filter by required experience level. Leave empty to include all levels.

## `sortBy` (type: `string`):

Order results by most recent postings or best relevance to your query.

## `hourlyRateMin` (type: `integer`):

Minimum hourly rate in USD. Only applies when Job Type is 'hourly' or 'all'.

## `hourlyRateMax` (type: `integer`):

Maximum hourly rate in USD. Only applies when Job Type is 'hourly' or 'all'.

## `budgetMin` (type: `integer`):

Minimum fixed project budget in USD. Only applies when Job Type is 'fixed' or 'all'.

## `budgetMax` (type: `integer`):

Maximum fixed project budget in USD. Only applies when Job Type is 'fixed' or 'all'.

## `duration` (type: `string`):

Filter jobs by expected project length.

## `workload` (type: `string`):

Filter by weekly hour commitment.

## `renderJs` (type: `boolean`):

Enable advanced rendering with residential proxy support. Required for Upwork pages to load correctly. Disable only for testing.

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

Number of job listings to return. Maximum is 10 (one page of Upwork results).

## `requestTimeoutSecs` (type: `integer`):

How long to wait for each request before timing out.

## `timeoutSecs` (type: `integer`):

Maximum total runtime for this actor run.

## Actor input object example

```json
{
  "searchQuery": "python developer",
  "jobType": "all",
  "experienceLevel": [
    "intermediate",
    "expert"
  ],
  "sortBy": "recency",
  "hourlyRateMin": 10,
  "hourlyRateMax": 50,
  "budgetMin": 100,
  "budgetMax": 5000,
  "duration": "all",
  "workload": "all",
  "renderJs": true,
  "maxItems": 10,
  "requestTimeoutSecs": 60,
  "timeoutSecs": 300
}
```

# 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": "python developer"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Upwork Scraper",
        "description": "Upwork job scraper that pulls live listings with full filter support for job type, budget, experience level, and duration, so recruiters and developers get structured data without manual searching.",
        "version": "0.0",
        "x-build-id": "ExEgHYwWk9Dt2NpTL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~upwork-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-upwork-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/kawsar~upwork-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-upwork-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/kawsar~upwork-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-upwork-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keywords to search for on Upwork (e.g. 'python developer', 'data analyst', 'react frontend')."
                    },
                    "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. Leave empty to include all levels.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "entry",
                                "intermediate",
                                "expert"
                            ],
                            "enumTitles": [
                                "Entry level",
                                "Intermediate",
                                "Expert"
                            ]
                        },
                        "default": []
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Order results by most recent postings or best relevance to your query.",
                        "default": "recency"
                    },
                    "hourlyRateMin": {
                        "title": "Hourly Rate Min ($/hr)",
                        "minimum": 0,
                        "maximum": 999,
                        "type": "integer",
                        "description": "Minimum hourly rate in USD. Only applies when Job Type is 'hourly' or 'all'."
                    },
                    "hourlyRateMax": {
                        "title": "Hourly Rate Max ($/hr)",
                        "minimum": 0,
                        "maximum": 999,
                        "type": "integer",
                        "description": "Maximum hourly rate in USD. Only applies when Job Type is 'hourly' or 'all'."
                    },
                    "budgetMin": {
                        "title": "Fixed Budget Min ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum fixed project budget in USD. Only applies when Job Type is 'fixed' or 'all'."
                    },
                    "budgetMax": {
                        "title": "Fixed Budget Max ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum fixed project budget in USD. Only applies when Job Type is 'fixed' or 'all'."
                    },
                    "duration": {
                        "title": "Project Duration",
                        "enum": [
                            "all",
                            "week",
                            "month",
                            "semester",
                            "ongoing"
                        ],
                        "type": "string",
                        "description": "Filter jobs by expected project length.",
                        "default": "all"
                    },
                    "workload": {
                        "title": "Workload",
                        "enum": [
                            "all",
                            "part_time",
                            "full_time"
                        ],
                        "type": "string",
                        "description": "Filter by weekly hour commitment.",
                        "default": "all"
                    },
                    "renderJs": {
                        "title": "Render JavaScript",
                        "type": "boolean",
                        "description": "Enable advanced rendering with residential proxy support. Required for Upwork pages to load correctly. Disable only for testing.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of job listings to return. Maximum is 10 (one page of Upwork results).",
                        "default": 10
                    },
                    "requestTimeoutSecs": {
                        "title": "Request Timeout (seconds)",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait for each request before timing out.",
                        "default": 60
                    },
                    "timeoutSecs": {
                        "title": "Actor Timeout (seconds)",
                        "minimum": 60,
                        "maximum": 3600,
                        "type": "integer",
                        "description": "Maximum total runtime for this actor run.",
                        "default": 300
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
