# Wellfound Startup Jobs Scraper (`trakk/wellfound-jobs-scraper`) Actor

Find fresh Wellfound startup jobs at scale. Export clean job listings, salary/equity signals, remote/location filters, and company hiring snapshots. Built for recruiters, founders, sales teams, and market researchers.

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

## Pricing

from $2.49 / 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 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

## Wellfound Jobs Scraper ✨

Turn Wellfound startup job pages into clean, export-ready datasets for recruiting, market research, lead generation, and hiring intelligence.

Use it to collect structured job listings, track new or changed roles over time, and summarize which companies are hiring across your target markets.

### 🚀 What You Can Do

- 🔎 Scrape Wellfound jobs from remote, location, role, and custom Wellfound URLs
- 🌍 Search by locations such as New York, San Francisco, London, India, Europe, Canada, and more
- 💼 Collect job titles, descriptions, locations, remote status, compensation, salary, and equity ranges
- 🏢 Build company hiring snapshots with job counts, role mix, location mix, and compensation ranges
- 🔔 Monitor sources for new, changed, and removed jobs across repeated runs
- 📊 Export results to JSON, CSV, Excel, XML, or use them through the Apify API

### 📦 Output Modes

Choose what you want to save:

| Mode | Best for | What you get |
| --- | --- | --- |
| `jobs` | Job boards, recruiting lists, compensation analysis | One record per job |
| `companies` | Company lead lists and hiring intelligence | One snapshot per company |
| `both` | Full hiring research | Jobs in the default dataset + company snapshots in the Companies output |

Company snapshots are stored in a separate Companies output, so the Jobs table stays clean and does not show unrelated empty columns.

### 🧾 Job Fields

Each job record can include:

- Job ID, title, primary role, job type
- Remote flag and location fields
- Full job description when available
- Compensation text
- Parsed salary currency, minimum, and maximum
- Parsed equity minimum and maximum
- Experience requirements
- Posted date and timestamp
- Company ID, name, slug, size, high concept, badges, logo, and profile URL
- Direct job URL, company job URL, source URL, source page, and scrape timestamp

### 🏢 Company Snapshot Fields

Company snapshots summarize the jobs found for each company in a source:

- Company name, slug, size, profile URL, logo, badges, and high concept
- Total jobs found
- Remote and onsite job counts
- Role titles found
- Job IDs found
- Locations and accepted remote locations
- Salary and equity range across the collected jobs
- Latest posted date
- Source URL and scrape timestamp

### ⚡ Quick Start

Scrape remote jobs:

```json
{
  "scrapeMode": "scrape",
  "inputMode": "REMOTE",
  "outputMode": "jobs",
  "pageLimit": 1,
  "maxItems": 1000
}
````

Scrape multiple Wellfound URLs:

```json
{
  "scrapeMode": "scrape",
  "inputMode": "URLS",
  "outputMode": "both",
  "urls": [
    { "url": "https://wellfound.com/location/new-york" },
    { "url": "https://wellfound.com/location/san-francisco" },
    { "url": "https://wellfound.com/remote" }
  ],
  "pageLimit": 2,
  "maxItems": 2000
}
```

Scrape by location names:

```json
{
  "scrapeMode": "scrape",
  "inputMode": "LOCATION",
  "outputMode": "both",
  "locations": ["New York", "London", "India"],
  "pageLimit": 1,
  "onlyRemoteJobs": false
}
```

### 🔔 Monitor Mode

Monitor mode is useful when you want to run the actor on a schedule and see what changed since the previous run.

```json
{
  "scrapeMode": "monitor",
  "inputMode": "LOCATION",
  "outputMode": "jobs",
  "locations": ["San Francisco"],
  "pageLimit": 1,
  "includeChangedJobs": true,
  "includeRemovedJobs": true
}
```

Monitor events include:

- `new` — a job appeared for the first time
- `changed` — title, role, compensation, description, remote status, location, job type, or experience requirements changed
- `removed` — a job disappeared from the monitored source

Use `resetMonitorState` when you want to start tracking from scratch.

### 🎯 Popular Use Cases

- Build a startup job database
- Track hiring activity by city, country, or region
- Find fast-hiring companies for sales or recruiting outreach
- Monitor competitor hiring
- Collect salary and equity signals from startup job listings
- Create alerts for new jobs in specific markets
- Research which companies are hiring remotely

### 📤 Outputs

The actor provides separate Output tabs:

- **Jobs** — job records from the default dataset
- **Monitor changes** — new, changed, and removed jobs when monitor mode is used
- **Company snapshots** — company hiring summaries from the Companies output

All outputs can be downloaded as JSON, CSV, Excel, XML, RSS, or HTML table where supported by Apify.

### 🧩 Example Job Record

```json
{
  "record_type": "job",
  "event_type": "current",
  "job_id": "4420399",
  "title": "Staff Software Engineer, Banking",
  "company_name": "Brex",
  "remote": false,
  "location_names": "New York City",
  "compensation": "$192k - $240k",
  "salary_currency": "$",
  "salary_min": 192000,
  "salary_max": 240000,
  "url": "https://wellfound.com/company/brex/jobs/staff-software-engineer-banking",
  "company_url": "https://wellfound.com/company/brex"
}
```

### 🧩 Example Company Snapshot

```json
{
  "record_type": "company_snapshot",
  "event_type": "current",
  "company_name": "Brex",
  "company_slug": "brex",
  "job_count": 12,
  "remote_job_count": 3,
  "onsite_job_count": 9,
  "role_titles": "Software Engineer, Product Manager, Data Analyst",
  "locations": "New York City, San Francisco",
  "salary_min": 120000,
  "salary_max": 240000,
  "company_url": "https://wellfound.com/company/brex"
}
```

### ⚙️ Input Tips

- Use `pageLimit` to control how many pages are collected per source.
- Set `pageLimit` to `0` to use all available pages up to the actor safety limit.
- Use `maxItems` to cap the total number of saved records.
- Use `onlyRemoteJobs` when you only want jobs marked as remote.
- Use `outputMode: "both"` when you want jobs and company snapshots in one run.

### ❓ FAQ

#### Can I scrape multiple cities at once?

Yes. Use `inputMode: "LOCATION"` and add multiple location names, or use `inputMode: "URLS"` and provide multiple Wellfound URLs.

#### Can I monitor jobs over time?

Yes. Use `scrapeMode: "monitor"` and schedule the actor. It will return new, changed, and removed listings compared with previous runs.

#### Are company snapshots separate from jobs?

Yes. Jobs are saved in the default dataset, and company snapshots are saved in a separate Companies output. This keeps each table clean and easy to export.

#### Does the actor parse compensation?

Yes, when compensation is present in the listing data. The actor keeps the original compensation text and also extracts salary and equity ranges when possible.

#### What happens when a job has no salary?

The job is still saved. Salary fields are simply omitted when Wellfound does not provide compensation for that listing.

### ✅ Good For

Recruiters, founders, sales teams, analysts, job-board builders, compensation researchers, and anyone who wants structured startup hiring data from Wellfound.

# Actor input Schema

## `scrapeMode` (type: `string`):

Choose a one-time scrape or compare this run against previous runs to detect changes.

## `inputMode` (type: `string`):

Choose whether to scrape remote jobs, location names, or your own Wellfound URLs.

## `outputMode` (type: `string`):

Choose jobs, company hiring summaries, or both. Jobs and company snapshots are saved in separate clean outputs.

## `urls` (type: `array`):

Use this when Source type is Wellfound URLs. Add location pages, remote pages, role pages, company job pages, or direct job pages.

## `locations` (type: `array`):

Use this when Source type is Location names. Enter city, country, or region names.

## `pageLimit` (type: `integer`):

Maximum pages to scrape from each source. Use 1 for a fast test. Use 0 to collect all available pages up to the safety limit.

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

Maximum records to save across selected outputs. The prefilled value is intentionally small for fast first runs.

## `onlyRemoteJobs` (type: `boolean`):

Keep only jobs marked as remote.

## `includeChangedJobs` (type: `boolean`):

In monitor mode, save jobs whose title, role, compensation, description, location, remote status, job type, or experience requirements changed.

## `includeRemovedJobs` (type: `boolean`):

In monitor mode, save jobs that disappeared from the monitored source.

## `resetMonitorState` (type: `boolean`):

Clear remembered jobs before this run. Use this when you want to start monitoring from scratch.

## `monitorStateStoreName` (type: `string`):

Named key-value store used to remember jobs between scheduled monitor runs.

## `maxRetries` (type: `integer`):

Maximum attempts for temporary network or website errors. The default works well for most runs.

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

Advanced setting. Leave unchanged for normal Apify runs.

## Actor input object example

```json
{
  "scrapeMode": "scrape",
  "inputMode": "REMOTE",
  "outputMode": "jobs",
  "urls": [
    {
      "url": "https://wellfound.com/remote"
    },
    {
      "url": "https://wellfound.com/location/new-york"
    }
  ],
  "locations": [
    "New York",
    "San Francisco",
    "London"
  ],
  "pageLimit": 1,
  "maxItems": 80,
  "onlyRemoteJobs": false,
  "includeChangedJobs": true,
  "includeRemovedJobs": true,
  "resetMonitorState": false,
  "monitorStateStoreName": "wellfound-jobs-monitor-state",
  "maxRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `changes` (type: `string`):

No description

## `companies` (type: `string`):

No description

## `companies_dataset` (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 = {
    "scrapeMode": "scrape",
    "inputMode": "REMOTE",
    "outputMode": "jobs",
    "urls": [
        {
            "url": "https://wellfound.com/remote"
        },
        {
            "url": "https://wellfound.com/location/new-york"
        }
    ],
    "locations": [
        "New York",
        "San Francisco",
        "London"
    ],
    "pageLimit": 1,
    "maxItems": 80,
    "onlyRemoteJobs": false,
    "includeChangedJobs": true,
    "includeRemovedJobs": true,
    "resetMonitorState": false,
    "monitorStateStoreName": "wellfound-jobs-monitor-state",
    "maxRetries": 3,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("trakk/wellfound-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "scrapeMode": "scrape",
    "inputMode": "REMOTE",
    "outputMode": "jobs",
    "urls": [
        { "url": "https://wellfound.com/remote" },
        { "url": "https://wellfound.com/location/new-york" },
    ],
    "locations": [
        "New York",
        "San Francisco",
        "London",
    ],
    "pageLimit": 1,
    "maxItems": 80,
    "onlyRemoteJobs": False,
    "includeChangedJobs": True,
    "includeRemovedJobs": True,
    "resetMonitorState": False,
    "monitorStateStoreName": "wellfound-jobs-monitor-state",
    "maxRetries": 3,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("trakk/wellfound-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "scrapeMode": "scrape",
  "inputMode": "REMOTE",
  "outputMode": "jobs",
  "urls": [
    {
      "url": "https://wellfound.com/remote"
    },
    {
      "url": "https://wellfound.com/location/new-york"
    }
  ],
  "locations": [
    "New York",
    "San Francisco",
    "London"
  ],
  "pageLimit": 1,
  "maxItems": 80,
  "onlyRemoteJobs": false,
  "includeChangedJobs": true,
  "includeRemovedJobs": true,
  "resetMonitorState": false,
  "monitorStateStoreName": "wellfound-jobs-monitor-state",
  "maxRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call trakk/wellfound-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wellfound Startup Jobs Scraper",
        "description": "Find fresh Wellfound startup jobs at scale. Export clean job listings, salary/equity signals, remote/location filters, and company hiring snapshots. Built for recruiters, founders, sales teams, and market researchers.",
        "version": "1.0",
        "x-build-id": "EKUNVLpFx22Lktlkp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trakk~wellfound-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trakk-wellfound-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/trakk~wellfound-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trakk-wellfound-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/trakk~wellfound-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trakk-wellfound-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "scrapeMode": {
                        "title": "Run type",
                        "enum": [
                            "scrape",
                            "monitor"
                        ],
                        "type": "string",
                        "description": "Choose a one-time scrape or compare this run against previous runs to detect changes.",
                        "default": "scrape"
                    },
                    "inputMode": {
                        "title": "Source type",
                        "enum": [
                            "REMOTE",
                            "LOCATION",
                            "URLS"
                        ],
                        "type": "string",
                        "description": "Choose whether to scrape remote jobs, location names, or your own Wellfound URLs.",
                        "default": "REMOTE"
                    },
                    "outputMode": {
                        "title": "Output",
                        "enum": [
                            "jobs",
                            "companies",
                            "both"
                        ],
                        "type": "string",
                        "description": "Choose jobs, company hiring summaries, or both. Jobs and company snapshots are saved in separate clean outputs.",
                        "default": "jobs"
                    },
                    "urls": {
                        "title": "Wellfound URLs",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Use this when Source type is Wellfound URLs. Add location pages, remote pages, role pages, company job pages, or direct job pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "locations": {
                        "title": "Location names",
                        "type": "array",
                        "description": "Use this when Source type is Location names. Enter city, country, or region names.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "pageLimit": {
                        "title": "Pages per source",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum pages to scrape from each source. Use 1 for a fast test. Use 0 to collect all available pages up to the safety limit.",
                        "default": 1
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum records to save across selected outputs. The prefilled value is intentionally small for fast first runs.",
                        "default": 1000
                    },
                    "onlyRemoteJobs": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "Keep only jobs marked as remote.",
                        "default": false
                    },
                    "includeChangedJobs": {
                        "title": "Include changed jobs",
                        "type": "boolean",
                        "description": "In monitor mode, save jobs whose title, role, compensation, description, location, remote status, job type, or experience requirements changed.",
                        "default": true
                    },
                    "includeRemovedJobs": {
                        "title": "Include removed jobs",
                        "type": "boolean",
                        "description": "In monitor mode, save jobs that disappeared from the monitored source.",
                        "default": true
                    },
                    "resetMonitorState": {
                        "title": "Reset monitor history",
                        "type": "boolean",
                        "description": "Clear remembered jobs before this run. Use this when you want to start monitoring from scratch.",
                        "default": false
                    },
                    "monitorStateStoreName": {
                        "title": "Monitor history store",
                        "type": "string",
                        "description": "Named key-value store used to remember jobs between scheduled monitor runs.",
                        "default": "wellfound-jobs-monitor-state"
                    },
                    "maxRetries": {
                        "title": "Retry attempts",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Maximum attempts for temporary network or website errors. The default works well for most runs.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Advanced setting. Leave unchanged for normal Apify runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```