# $1 \[Cheapest] Upwork Jobs Feed (Ultrafast) (`bestanalytics/upwork-jobs-feed`) Actor

Stream fresh Upwork job listings from a curated, indexed dataset. Filter by category, level, budget, hourly rate, full-text search, and date ranges. Cursor-paginated for stable results across concurrent updates.

- **URL**: https://apify.com/bestanalytics/upwork-jobs-feed.md
- **Developed by:** [Paul Anaytics](https://apify.com/bestanalytics) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Feed

Fresh Upwork job listings from a curated, indexed warehouse — fast, filterable, and ready to consume.

**Pricing:** **$0.001 per job retrieved**. You only pay for what you receive.

**Data coverage:** **from 2026-06-01 onward** (≈ 117 k jobs and growing — new listings added every few minutes). Anything older is not available.

Every filter is indexed, so even broad queries return in <50 ms server-side.

### What you get

| Field | Type | Notes |
| --- | --- | --- |
| `job_id` | string | Stable Upwork listing ID — use as PK |
| `link` | string | Direct URL to the listing on Upwork |
| `category` | string | Top-level category name |
| `category_id` | int | Numeric category — stable across renames |
| `job_title` | string | |
| `description` | string | Full description text |
| `skills` | string | Semicolon- or comma-separated tags |
| `level` | string | `entry` \| `intermediate` \| `expert` |
| `fixed_budget` | float \| null | When set, this is a fixed-price job |
| `hourly_min` | float \| null | |
| `hourly_max` | float \| null | |
| `published_on` | ISO 8601 | When the client published the job |
| `created_on` | ISO 8601 | When we scraped the listing |

### Filters — all optional

#### Date range

- **Published — relative range** (recommended): pick `Last hour / 24h / 3d / 7d / 30d / 90d`. Easiest way to track "what's new".
- **Published from / to** (absolute): use date pickers for exact ranges. Ignored when the relative range above is set.
- **Scraped from / to**: filter by the date we ingested the job (independent of when it was published).

#### Categories

Multi-select. Choose one or more:

`Design & Creative` · `Sales & Marketing` · `Web Mobile & Software Dev` · `Admin Support` · `Engineering & Architecture` · `Accounting & Consulting` · `Writing` · `Data Science & Analytics` · `Customer Service` · `IT & Networking` · `Translation` · `Legal`

#### Experience levels

Multi-select: `Entry`, `Intermediate`, `Expert`.

#### Text search — boolean syntax

Four independent search fields, all case-insensitive. They use a **friendly boolean syntax**:

| You write | Means |
| --- | --- |
| `python` | Title/desc must contain "python" |
| `python and django` | Both required |
| `python or sql` | Either |
| `"power bi"` | The exact phrase |
| `python and not junior` | Has "python", does NOT have "junior" |
| `(excel or python) and "power bi"` | Grouped |

- **Search — title + description**: applies to both columns
- **Search — title only**: title only
- **Search — description only**: description only
- **Exclude from title / description**: comma-separated tokens to remove. Example: `junior, intern, entry-level`

⚠ MySQL FULLTEXT ignores tokens shorter than 4 characters (`sql`, `php`, `go`, `r`). Use longer phrases when possible — e.g., `"sql server"` instead of `sql`.

#### Skills

Multi-tag input. Type each skill, hit Enter to add. Then choose:

- **Any (OR)** — job has at least one matching skill
- **All (AND)** — job has every selected skill

#### Description length

Drop low-effort jobs by setting **Minimum description length**. Common values:
- `300` — filters out one-line postings
- `1000` — only detailed briefs
- `2000` — premium, well-specified jobs

#### Money

- **Fixed budget min / max** ($USD)
- **Hourly min ≥ / Hourly max ≤** ($USD/hour)
- **Fixed-price filter** — only fixed | exclude fixed | either
- **Hourly filter** — only hourly | exclude hourly | either

#### Sort

- Published — newest / oldest first *(default = newest)*
- Scraped — newest / oldest first
- Fixed budget — highest first
- Hourly max — highest first

### Cost control

| `maxItems` | Cost |
| --- | --- |
| 100 | $0.30 |
| 1 000 *(default)* | $3.00 |
| 10 000 | $30.00 |
| 100 000 | $300.00 |

The actor stops as soon as the cap is hit, so you never overspend by accident.

### Examples

**Last 24 h of expert Python work over $1k:**
```json
{
  "publishedRange": "24h",
  "categories": ["Data Science & Analytics", "Web Mobile & Software Dev"],
  "levels": ["expert"],
  "q": "python",
  "budgetMin": 1000,
  "qTitleExclude": "junior, intern",
  "minDescriptionLength": 500,
  "sort": "budget_desc",
  "maxItems": 200
}
````

**Premium design briefs this week:**

```json
{
  "publishedRange": "7d",
  "categories": ["Design & Creative"],
  "hasBudget": "true",
  "minDescriptionLength": 1000,
  "sort": "budget_desc",
  "maxItems": 50
}
```

**Power BI experts willing to take fixed-price work:**

```json
{
  "publishedRange": "30d",
  "skills": ["power bi", "tableau"],
  "skillsMode": "any",
  "q": "(\"power bi\" or tableau) and dashboard",
  "qDescriptionExclude": "junior",
  "hasBudget": "true",
  "maxItems": 100
}
```

### Pagination

Handled internally with stable cursors. Stops automatically when the API runs out of rows OR `maxItems` is reached.

### Support

Questions, custom plans, or volume discounts? Open an issue on the actor page or message the maintainer.

# Actor input Schema

## `publishedRange` (type: `string`):

Quick preset: jobs published within the last N hours/days. Easier than picking dates. Leave empty to use absolute date pickers below.

## `publishedFrom` (type: `string`):

Only jobs published on/after this date. Ignored when 'Published range' is set.

## `publishedTo` (type: `string`):

Only jobs published on/before this date.

## `createdFrom` (type: `string`):

Only jobs scraped on/after this date. Cannot be earlier than 2026-06-01 — values before that are clamped.

## `createdTo` (type: `string`):

Only jobs scraped on/before this date.

## `categories` (type: `array`):

Select one or more Upwork categories. Empty = all categories.

## `levels` (type: `array`):

Select one or more levels. Empty = all levels.

## `q` (type: `string`):

Boolean expression searched across title AND description. Supports: AND, OR, NOT, parentheses, "quoted phrases". Case-insensitive. Examples: 'python and not junior', '(excel or python) and "power bi"'. Tokens shorter than 4 chars are ignored.

## `qTitle` (type: `string`):

Same boolean syntax as above, but matches only against the job title.

## `qTitleExclude` (type: `string`):

Comma-separated tokens. Jobs whose TITLE contains any of these words are removed. Example: 'junior, intern, entry-level'.

## `qDescription` (type: `string`):

Boolean search against the full job description.

## `qDescriptionExclude` (type: `string`):

Comma-separated tokens. Jobs whose DESCRIPTION contains any of these are removed.

## `minDescriptionLength` (type: `integer`):

Drop jobs with descriptions shorter than this many characters (good for filtering low-effort posts).

## `skills` (type: `array`):

Comma-separated skill tags (e.g., python, django, "power bi"). Matched against the job's Upwork-tagged skills.

## `skillsMode` (type: `string`):

How multiple skills combine.

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

Minimum fixed-price budget in USD. Excludes jobs with no fixed budget.

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

Maximum fixed-price budget in USD.

## `hourlyMinGte` (type: `integer`):

Hourly rate low end is at least this many USD/hour.

## `hourlyMaxLte` (type: `integer`):

Hourly rate high end is at most this many USD/hour.

## `hasBudget` (type: `string`):

Filter by presence of a fixed-price budget.

## `hasHourly` (type: `string`):

Filter by presence of an hourly rate.

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

Order of results.

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

Hard cap on items pushed to the dataset. Each item costs $0.003. Default 1000 = $3.00.

## Actor input object example

```json
{
  "publishedRange": "",
  "categories": [],
  "levels": [],
  "skills": [],
  "skillsMode": "any",
  "hasBudget": "",
  "hasHourly": "",
  "sort": "published_desc",
  "maxItems": 1000
}
```

# 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 = {};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "$1 [Cheapest] Upwork Jobs Feed (Ultrafast)",
        "description": "Stream fresh Upwork job listings from a curated, indexed dataset. Filter by category, level, budget, hourly rate, full-text search, and date ranges. Cursor-paginated for stable results across concurrent updates.",
        "version": "0.1",
        "x-build-id": "C2HBxP6XgdnSIV2JU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bestanalytics~upwork-jobs-feed/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bestanalytics-upwork-jobs-feed",
                "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/bestanalytics~upwork-jobs-feed/runs": {
            "post": {
                "operationId": "runs-sync-bestanalytics-upwork-jobs-feed",
                "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/bestanalytics~upwork-jobs-feed/run-sync": {
            "post": {
                "operationId": "run-sync-bestanalytics-upwork-jobs-feed",
                "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": {
                    "publishedRange": {
                        "title": "Published — relative range",
                        "enum": [
                            "",
                            "1h",
                            "24h",
                            "3d",
                            "7d",
                            "30d",
                            "90d"
                        ],
                        "type": "string",
                        "description": "Quick preset: jobs published within the last N hours/days. Easier than picking dates. Leave empty to use absolute date pickers below.",
                        "default": ""
                    },
                    "publishedFrom": {
                        "title": "Published from (absolute)",
                        "type": "string",
                        "description": "Only jobs published on/after this date. Ignored when 'Published range' is set."
                    },
                    "publishedTo": {
                        "title": "Published to (absolute)",
                        "type": "string",
                        "description": "Only jobs published on/before this date."
                    },
                    "createdFrom": {
                        "title": "Scraped from (date)",
                        "type": "string",
                        "description": "Only jobs scraped on/after this date. Cannot be earlier than 2026-06-01 — values before that are clamped."
                    },
                    "createdTo": {
                        "title": "Scraped to (date)",
                        "type": "string",
                        "description": "Only jobs scraped on/before this date."
                    },
                    "categories": {
                        "title": "Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select one or more Upwork categories. Empty = all categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Design & Creative",
                                "Sales & Marketing",
                                "Web Mobile & Software Dev",
                                "Admin Support",
                                "Engineering & Architecture",
                                "Accounting & Consulting",
                                "Writing",
                                "Data Science & Analytics",
                                "Customer Service",
                                "IT & Networking",
                                "Translation",
                                "Legal"
                            ]
                        },
                        "default": []
                    },
                    "levels": {
                        "title": "Experience levels",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select one or more levels. Empty = all levels.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "entry",
                                "intermediate",
                                "expert"
                            ],
                            "enumTitles": [
                                "Entry",
                                "Intermediate",
                                "Expert"
                            ]
                        },
                        "default": []
                    },
                    "q": {
                        "title": "Search — title + description",
                        "type": "string",
                        "description": "Boolean expression searched across title AND description. Supports: AND, OR, NOT, parentheses, \"quoted phrases\". Case-insensitive. Examples: 'python and not junior', '(excel or python) and \"power bi\"'. Tokens shorter than 4 chars are ignored."
                    },
                    "qTitle": {
                        "title": "Search — title only",
                        "type": "string",
                        "description": "Same boolean syntax as above, but matches only against the job title."
                    },
                    "qTitleExclude": {
                        "title": "Exclude from title",
                        "type": "string",
                        "description": "Comma-separated tokens. Jobs whose TITLE contains any of these words are removed. Example: 'junior, intern, entry-level'."
                    },
                    "qDescription": {
                        "title": "Search — description only",
                        "type": "string",
                        "description": "Boolean search against the full job description."
                    },
                    "qDescriptionExclude": {
                        "title": "Exclude from description",
                        "type": "string",
                        "description": "Comma-separated tokens. Jobs whose DESCRIPTION contains any of these are removed."
                    },
                    "minDescriptionLength": {
                        "title": "Minimum description length (chars)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop jobs with descriptions shorter than this many characters (good for filtering low-effort posts)."
                    },
                    "skills": {
                        "title": "Skills",
                        "type": "array",
                        "description": "Comma-separated skill tags (e.g., python, django, \"power bi\"). Matched against the job's Upwork-tagged skills.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "skillsMode": {
                        "title": "Skills match mode",
                        "enum": [
                            "any",
                            "all"
                        ],
                        "type": "string",
                        "description": "How multiple skills combine.",
                        "default": "any"
                    },
                    "budgetMin": {
                        "title": "Fixed budget min ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum fixed-price budget in USD. Excludes jobs with no fixed budget."
                    },
                    "budgetMax": {
                        "title": "Fixed budget max ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum fixed-price budget in USD."
                    },
                    "hourlyMinGte": {
                        "title": "Hourly min ≥ ($/h)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hourly rate low end is at least this many USD/hour."
                    },
                    "hourlyMaxLte": {
                        "title": "Hourly max ≤ ($/h)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hourly rate high end is at most this many USD/hour."
                    },
                    "hasBudget": {
                        "title": "Fixed-price filter",
                        "enum": [
                            "",
                            "true",
                            "false"
                        ],
                        "type": "string",
                        "description": "Filter by presence of a fixed-price budget.",
                        "default": ""
                    },
                    "hasHourly": {
                        "title": "Hourly filter",
                        "enum": [
                            "",
                            "true",
                            "false"
                        ],
                        "type": "string",
                        "description": "Filter by presence of an hourly rate.",
                        "default": ""
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "published_desc",
                            "published_asc",
                            "created_desc",
                            "created_asc",
                            "budget_desc",
                            "hourly_max_desc"
                        ],
                        "type": "string",
                        "description": "Order of results.",
                        "default": "published_desc"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Hard cap on items pushed to the dataset. Each item costs $0.003. Default 1000 = $3.00.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
