# Upwork Job Scraper (`khadinakbar/upwork-job-scraper`) Actor

Scrape Upwork public job search results — title, budget, skills, client country/spend/verified status. Keyword or URL input. MCP-ready, no login required. Honest-fail on Cloudflare blocks.

- **URL**: https://apify.com/khadinakbar/upwork-job-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Jobs, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 job returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/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 Job Scraper

**Scrape Upwork public job search results** — title, budget, skills, client country, payment-verified status, client spend, and posted timestamp. **No login required, MCP-ready, honest-fail on Cloudflare blocks.** Built for freelancers monitoring new jobs, agencies sourcing pipeline, and researchers tracking the freelance market.

### What does Upwork Job Scraper do?

This Actor scrapes [Upwork.com](https://www.upwork.com) public job search results by keyword query or by direct search URL. For each job posting it returns a structured record with title, snippet description, budget (parsed into hourly range or fixed price), required skills, client country, payment-verified status, total client spend, average client rating, hire count, and posted timestamp (raw and ISO 8601). The Actor runs on Apify infrastructure with proxy rotation, browser fingerprinting, and session management to bypass Upwork's Cloudflare protection. Use the Apify Console, Apify API, MCP, schedules, or integrations (Zapier, Make, Slack) to drive it.

### Why use Upwork Job Scraper?

- **Freelancers** — set up a recurring run every 30 minutes to surface fresh jobs in your niche before the proposal flood.
- **Agencies / lead-gen teams** — pipe verified, payment-verified, high-budget jobs into your CRM as leads.
- **Researchers / journalists** — track salary trends, skill demand shifts, and freelance market dynamics.
- **AI agents** — call the MCP tool `apify--upwork-job-scraper` to surface live Upwork opportunities into an LLM-driven workflow.
- **Niche monitoring** — keyword + filter combos (payment-verified + $10K+ spend + expert tier) give clean signal vs raw search noise.

### How to use Upwork Job Scraper

1. Open the Actor on Apify Console and click **Try for free**.
2. Enter one or more keyword queries in **Search keywords** (e.g. `react developer`, `shopify expert`). Or paste a filtered Upwork search URL into **Upwork search URLs**.
3. Set **Max jobs to return** (default 50). Add filters: job type, experience level, payment-verified, min hourly rate, min client spend.
4. Click **Save & Start**. The Actor pushes each job to the dataset as it finds one and bills per result.
5. Download the dataset as **JSON, CSV, Excel, HTML, RSS, or XML** from the Output tab, or pull via API.

### Input

All input fields are optional except that you must provide either **searchQueries** or **startUrls** (or both).

```json
{
  "searchQueries": ["react developer", "shopify expert"],
  "maxResults": 100,
  "sortBy": "recency",
  "jobType": "hourly",
  "experienceLevel": "expert",
  "paymentVerified": true,
  "minHourlyRate": 40,
  "minClientSpend": "10k"
}
````

| Field | Type | Description |
|---|---|---|
| `searchQueries` | string\[] | Keyword queries to run through Upwork search. |
| `startUrls` | url\[] | Direct Upwork search URLs to crawl as-is. |
| `maxResults` | int | Hard cap on jobs pushed and charged. Default 50, max 1000. |
| `maxPagesPerQuery` | int | Pages per query (50 jobs/page). Default 3. |
| `sortBy` | enum | `recency` (default) or `relevance`. |
| `jobType` | enum | `all`, `hourly`, or `fixed`. |
| `experienceLevel` | enum | `all`, `entry`, `intermediate`, or `expert`. |
| `paymentVerified` | bool | Filter to payment-verified clients only. |
| `minHourlyRate` | int | Min $/hr for hourly jobs. |
| `minClientSpend` | enum | `any`, `1k`, or `10k`. |
| `proxyConfiguration` | object | Defaults to Apify proxy BUYPROXIES94952 (US). |

### Output

One record per unique Upwork job:

```json
{
  "jobId": "~021782314050491478016",
  "title": "Senior React Developer for SaaS Dashboard",
  "jobUrl": "https://www.upwork.com/jobs/senior-react-developer-for-saas-dashboard_~021782314050491478016/",
  "description": "We need an experienced React dev to rebuild our analytics dashboard...",
  "jobType": "Hourly",
  "budget": "$40-$80/hr",
  "hourlyRange": { "min": 40, "max": 80, "currency": "USD" },
  "fixedPrice": null,
  "experienceLevel": "Expert",
  "duration": "3 to 6 months",
  "engagement": "Less than 30 hrs/week",
  "postedAtRaw": "2 hours ago",
  "postedAt": "2026-06-20T10:17:00.000Z",
  "skills": ["React", "TypeScript", "Tailwind CSS", "Node.js"],
  "proposalsRange": "5 to 10",
  "connects": 16,
  "clientCountry": "United States",
  "clientCity": "Austin",
  "clientPaymentVerified": true,
  "clientSpend": 45782,
  "clientRating": 4.92,
  "clientHires": 23,
  "clientReviewsCount": 18
}
```

Export the dataset as JSON, CSV, Excel, HTML, RSS, or XML.

### Data table

| Field | Type | Description |
|---|---|---|
| `jobId` | string | Upwork ciphertext ID (~021...). |
| `title` | string | Job posting title. |
| `jobUrl` | string | Public posting URL. |
| `description` | string | Snippet / description. |
| `jobType` | string | Hourly or Fixed. |
| `budget` | string | Raw budget text. |
| `hourlyRange` | object | { min, max, currency }. |
| `fixedPrice` | object | { amount, currency }. |
| `experienceLevel` | string | Entry / Intermediate / Expert. |
| `postedAt` | string | ISO 8601 timestamp. |
| `skills` | array | Skill tags. |
| `clientCountry` | string | Client country. |
| `clientPaymentVerified` | bool | Payment method verified. |
| `clientSpend` | number | Total historical spend (USD). |
| `clientRating` | number | 0-5 rating. |
| `clientHires` | int | Past hires. |

### Pricing

Pay-Per-Event (PPE) — you only pay for what the Actor produces:

| Event | Price |
|---|---|
| `apify-actor-start` | **$0.00005** per run (covers init) |
| `job-found` | **$0.005** per unique job returned |

**Typical cost:** 50 jobs = **$0.25** per run. 1,000 jobs/day = **$5.00/day**. No subscription, no setup fee.

Also enabled: **Pay-Per-Usage** (compute + proxy passthrough) for power users running massive jobs. Pick at run time.

### Tips

- **Use `sortBy: recency` for monitoring** — pairs with Apify Schedules to fire every 15-30 min and pipe new jobs into Slack/Sheets.
- **Stack filters for signal** — `paymentVerified: true` + `minClientSpend: "10k"` + `experienceLevel: "expert"` removes 80% of noise.
- **Direct URLs win** — build the perfect filter in the Upwork UI, paste into `startUrls`. Avoids translating filter combos.
- **Niche keywords > broad** — `langchain agent developer` returns 5 highly relevant jobs; `developer` returns 5000 noisy ones.

### Limitations & reliability disclosure

Upwork is protected by **Cloudflare Enterprise** with behavioral bot detection. This Actor uses Apify datacenter-class proxies (BUYPROXIES94952 group) + Crawlee browser fingerprinting + session pooling. It does **NOT** guarantee 100% bypass:

- Expect ~60-80% success rate per page in typical conditions.
- On hard blocks, the actor honest-fails (`Actor.fail()`) rather than silently returning empty data. You only pay for jobs actually delivered, plus the start fee.
- Detail-page enrichment (full description, all attachments, full client history) requires Upwork login and is **NOT** scraped here.
- For 99%+ reliability on Upwork at scale, look for actors that use in-house Upwork account pools + premium proxies (priced higher).

### FAQ

**Is scraping Upwork legal?**
Scraping public web pages is generally legal under cases like *hiQ v. LinkedIn*. You are responsible for your own use. Do not scrape behind login, do not republish copyrighted job descriptions verbatim, and respect Upwork's Terms of Service. This Actor scrapes only public search results.

**Do I need an Upwork account / cookies?**
No. The Actor uses no login and reads only Upwork's public job search pages.

**Why did the run fail with "Cloudflare blocked all pages"?**
Upwork's anti-bot rotated against the proxy pool. Retry — different proxy session typically clears. Or simplify queries / reduce `maxPagesPerQuery`.

**Can I monitor a specific saved search?**
Yes — build the filtered search in the Upwork UI, copy the URL, paste into `startUrls`. Schedule the actor for recurring runs.

**Does this work as an MCP tool for Claude / ChatGPT?**
Yes. Add `khadinakbar/upwork-job-scraper` to your MCP client (mcp.apify.com). The tool description is written for agent consumption.

### Support

Open an issue on the Actor's [Issues tab](https://console.apify.com) on Apify Console. For custom enrichment (detail-page scraping with cookies, multi-region rollup, CRM integration), [contact me](https://apify.com/khadinakbar) for a tailored build.

***

*Built by khadinakbar. Part of the [jobs scraper portfolio](https://apify.com/khadinakbar) — pairs with `linkedin-jobs-scraper`, `indeed-job-scraper`, `google-jobs-scraper`, and `jobs-scraper` (multi-source).*

# Actor input Schema

## `searchQueries` (type: `array`):

List of keyword queries to search on Upwork Jobs (e.g. \['react developer', 'shopify expert']). Each query runs through Upwork's public job search. Use specific niche keywords for higher signal. Leave empty if you pass startUrls instead.

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

Direct Upwork job-search URLs (e.g. https://www.upwork.com/nx/search/jobs/?q=python\&sort=recency). Use when you already built a filtered URL in the Upwork UI and want the scraper to follow it exactly. Compatible with searchQueries.

## `maxResults` (type: `integer`):

Hard cap on total jobs pushed AND charged across all queries/URLs. Stops the run once reached. Range 1-1000. Default 50.

## `maxPagesPerQuery` (type: `integer`):

How many result pages to crawl per search query (50 jobs/page). Range 1-20. Default 3.

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

Result sort: 'recency' = newest first (recommended for monitoring), 'relevance' = Upwork relevance algorithm.

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

Filter by contract type. 'all' = no filter, 'hourly' = hourly contracts only, 'fixed' = fixed-price only.

## `experienceLevel` (type: `string`):

Filter by required contractor tier. 'all' = no filter, 'entry' = entry level, 'intermediate' = intermediate, 'expert' = expert.

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

If true, only return jobs from clients with Upwork-verified payment method. Filters out low-quality / risky postings.

## `minHourlyRate` (type: `integer`):

Only return hourly jobs at or above this rate. Ignored for fixed-price jobs. Leave empty for no filter.

## `minClientSpend` (type: `string`):

Filter by client historical spend. 'any' = no filter, '1k' = $1K+, '10k' = $10K+ (serious clients).

## `proxyConfiguration` (type: `object`):

Defaults to Apify proxy BUYPROXIES94952 group (US). Override only if you have residential or custom proxies — Upwork is Cloudflare-protected; datacenter proxies block ~50% of requests.

## Actor input object example

```json
{
  "searchQueries": [
    "javascript developer"
  ],
  "startUrls": [],
  "maxResults": 50,
  "maxPagesPerQuery": 3,
  "sortBy": "recency",
  "jobType": "all",
  "experienceLevel": "all",
  "paymentVerified": false,
  "minClientSpend": "any",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ],
    "countryCode": "US"
  }
}
```

# Actor output Schema

## `jobs` (type: `string`):

No description

## `runState` (type: `string`):

No description

# 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 = {
    "searchQueries": [
        "javascript developer"
    ],
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "BUYPROXIES94952"
        ],
        "countryCode": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/upwork-job-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 = {
    "searchQueries": ["javascript developer"],
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["BUYPROXIES94952"],
        "countryCode": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/upwork-job-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 '{
  "searchQueries": [
    "javascript developer"
  ],
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ],
    "countryCode": "US"
  }
}' |
apify call khadinakbar/upwork-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Upwork Job Scraper",
        "description": "Scrape Upwork public job search results — title, budget, skills, client country/spend/verified status. Keyword or URL input. MCP-ready, no login required. Honest-fail on Cloudflare blocks.",
        "version": "1.0",
        "x-build-id": "qwng7dsrjE9bdGZPR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~upwork-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-upwork-job-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/khadinakbar~upwork-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-upwork-job-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/khadinakbar~upwork-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-upwork-job-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": {
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "List of keyword queries to search on Upwork Jobs (e.g. ['react developer', 'shopify expert']). Each query runs through Upwork's public job search. Use specific niche keywords for higher signal. Leave empty if you pass startUrls instead.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Upwork search URLs",
                        "type": "array",
                        "description": "Direct Upwork job-search URLs (e.g. https://www.upwork.com/nx/search/jobs/?q=python&sort=recency). Use when you already built a filtered URL in the Upwork UI and want the scraper to follow it exactly. Compatible with searchQueries.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max jobs to return",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on total jobs pushed AND charged across all queries/URLs. Stops the run once reached. Range 1-1000. Default 50.",
                        "default": 50
                    },
                    "maxPagesPerQuery": {
                        "title": "Max pages per query",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many result pages to crawl per search query (50 jobs/page). Range 1-20. Default 3.",
                        "default": 3
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Result sort: 'recency' = newest first (recommended for monitoring), 'relevance' = Upwork relevance algorithm.",
                        "default": "recency"
                    },
                    "jobType": {
                        "title": "Job type filter",
                        "enum": [
                            "all",
                            "hourly",
                            "fixed"
                        ],
                        "type": "string",
                        "description": "Filter by contract type. 'all' = no filter, 'hourly' = hourly contracts only, 'fixed' = fixed-price only.",
                        "default": "all"
                    },
                    "experienceLevel": {
                        "title": "Experience level",
                        "enum": [
                            "all",
                            "entry",
                            "intermediate",
                            "expert"
                        ],
                        "type": "string",
                        "description": "Filter by required contractor tier. 'all' = no filter, 'entry' = entry level, 'intermediate' = intermediate, 'expert' = expert.",
                        "default": "all"
                    },
                    "paymentVerified": {
                        "title": "Payment-verified clients only",
                        "type": "boolean",
                        "description": "If true, only return jobs from clients with Upwork-verified payment method. Filters out low-quality / risky postings.",
                        "default": false
                    },
                    "minHourlyRate": {
                        "title": "Min hourly rate (USD)",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Only return hourly jobs at or above this rate. Ignored for fixed-price jobs. Leave empty for no filter."
                    },
                    "minClientSpend": {
                        "title": "Min client total spend",
                        "enum": [
                            "any",
                            "1k",
                            "10k"
                        ],
                        "type": "string",
                        "description": "Filter by client historical spend. 'any' = no filter, '1k' = $1K+, '10k' = $10K+ (serious clients).",
                        "default": "any"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Defaults to Apify proxy BUYPROXIES94952 group (US). Override only if you have residential or custom proxies — Upwork is Cloudflare-protected; datacenter proxies block ~50% of requests.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "BUYPROXIES94952"
                            ],
                            "countryCode": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
