# Wellfound Scraper – Startup Jobs, Remote Roles & Compensation (`abotapi/wellfound-jobs-scraper`) Actor

Extract startup job listings from Wellfound.com with location, keyword, role, remote, compensation, company badge, and MCP connector export options.

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

## Pricing

from $1.00 / 1,000 dataset items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

Extract startup job listings from Wellfound into a clean Apify dataset. The actor supports location search and direct Wellfound URL mode, then lets you narrow results by keywords, role terms, remote status, compensation availability, and company hiring badges. Each saved row includes job, company, compensation, location, remote, badge, and description fields where available.

### Why This Scraper?

- Two clear modes: build searches from Wellfound locations or paste Wellfound URLs.
- Useful job fields in every row: title, company, URL, role, locations, remote status, compensation, and posting date.
- Company signals included when available: logo, company size, high concept, hiring status, investor badge, and responder badges.
- Full description text is included for location-search rows when Wellfound exposes it in the listing data.
- Output limits and filters apply in both modes, so pasted URL runs can still be narrowed.
- MCP connector export can send a concise job summary into Notion, Linear, Airtable, or Apify connectors while the full record stays in the dataset.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live listing.

| Field | Example |
| --- | --- |
| `jobId` | `00000001` |
| `jobUrl` | `https://wellfound.com/jobs/00000001-sample-role` |
| `jobSlug` | `sample-role` |
| `jobTitle` | `Sample Platform Engineer` |
| `descriptionText` | `Full role description text appears here.` |
| `jobType` | `full-time` |
| `primaryRoleTitle` | `Software Engineer` |
| `compensation` | `$100k - $150k` |
| `compensationMin` | `100000` |
| `compensationMax` | `150000` |
| `compensationCurrency` | `$` |
| `hasCompensation` | `true` |
| `locations` | `["San Francisco"]` |
| `acceptedRemoteLocations` | `["United States"]` |
| `remote` | `true` |
| `companyName` | `Sample Company` |
| `companyUrl` | `https://wellfound.com/company/sample-company` |
| `companyLogoUrl` | `https://photos.wellfound.com/startups/i/00000001-medium_jpg.jpg` |
| `companySize` | `SIZE_51_200` |
| `companyHighConcept` | `Sample company summary` |
| `allBadgeLabels` | `["Actively Hiring", "Top Investors"]` |
| `postedAt` | `2026-01-01T00:00:00Z` |
| `sourceUrl` | `https://wellfound.com/location/san-francisco` |

### How to Use

Search one location:

```json
{
  "mode": "search",
  "locations": ["san-francisco"],
  "maxItems": 20
}
````

Search multiple locations with filters:

```json
{
  "mode": "search",
  "locations": ["san-francisco", "new-york"],
  "keywords": ["python", "platform"],
  "roleKeywords": ["engineer"],
  "requireCompensation": true,
  "maxItems": 25
}
```

Use direct Wellfound URLs:

```json
{
  "mode": "url",
  "startUrls": [
    { "url": "https://wellfound.com/location/san-francisco" },
    { "url": "https://wellfound.com/jobs" }
  ],
  "remoteOnly": true,
  "maxItems": 10
}
```

Send a job digest into an app connector:

```json
{
  "mode": "search",
  "locations": ["london"],
  "maxItems": 10,
  "mcpConnectors": ["YOUR_CONNECTOR_ID"],
  "notionParentPageUrl": "https://www.notion.so/your-page",
  "maxNotifyListings": 10
}
```

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | Choose `search` for location search or `url` for pasted Wellfound links. |
| `locations` | array | `["san-francisco"]` | Location slugs or names for search mode. |
| `startUrls` | array | sample URLs | Wellfound `/jobs` or `/location/...` URLs for URL mode. |
| `keywords` | array | empty | Keeps rows where at least one term appears in the job, company, role, location, badge, compensation, or description text. |
| `roleKeywords` | array | empty | Keeps rows where at least one term appears in the job title or primary role. |
| `remoteOnly` | boolean | `false` | Keeps only remote jobs. |
| `requireCompensation` | boolean | `false` | Keeps only jobs with compensation text. |
| `activelyHiringOnly` | boolean | `false` | Keeps only jobs with an actively hiring company badge. |
| `maxItems` | integer | `20` | Maximum matching rows to save. Runs can return fewer rows when filters match fewer current jobs. |
| `maxPages` | integer | `50` | Maximum pages to read per location or URL source. Defaults high because `maxItems` is the primary output cap. |
| `proxy` | object | Apify residential | Connection settings. The default is recommended for Wellfound. |
| `mcpConnectors` | array | empty | Optional connector ids for sending a concise summary into your apps. |
| `notionParentPageUrl` | string | empty | Required only for Notion page export. |
| `maxNotifyListings` | integer | `50` | Maximum rows to send to each selected connector. Does not affect the dataset. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live listing.

```json
{
  "jobId": "00000001",
  "jobUrl": "https://wellfound.com/jobs/00000001-sample-platform-engineer",
  "jobSlug": "sample-platform-engineer",
  "jobTitle": "Sample Platform Engineer",
  "descriptionText": "Full role description text appears here.",
  "descriptionLength": 39,
  "jobType": "full-time",
  "primaryRoleTitle": "Software Engineer",
  "compensation": "$100k - $150k",
  "compensationMin": 100000,
  "compensationMax": 150000,
  "compensationCurrency": "$",
  "hasCompensation": true,
  "hasEquity": false,
  "locations": ["San Francisco"],
  "acceptedRemoteLocations": ["United States"],
  "remote": true,
  "remoteKind": "remote",
  "yearsExperienceMin": 3,
  "yearsExperienceMax": 7,
  "postedAtUnix": 1700000000,
  "postedAt": "2026-01-01T00:00:00Z",
  "companyId": "00000001",
  "companyName": "Sample Company",
  "companySlug": "sample-company",
  "companyUrl": "https://wellfound.com/company/sample-company",
  "companyLogoUrl": "https://photos.wellfound.com/startups/i/00000001-medium_jpg.jpg",
  "companySize": "SIZE_51_200",
  "companyHighConcept": "Sample company summary",
  "allBadgeLabels": ["Actively Hiring", "Top Investors"],
  "activelyHiring": true,
  "hasTopInvestors": true,
  "quickResponder": false,
  "topResponder": false,
  "sourceUrl": "https://wellfound.com/location/san-francisco",
  "sourceLabel": "san-francisco",
  "scrapedAt": "2026-01-01T00:00:00Z"
}
```

### Send Results Into Your Apps

The optional MCP connector inputs let you send a condensed, human-readable summary of each selected job into your connected apps. Authorize a connector under Apify > Settings > API & Integrations, select it in `mcpConnectors`, and set `notionParentPageUrl` when using Notion.

The connector export is a side output. It does not change the dataset, and connector write errors do not fail the run. The complete record always remains available in the Apify dataset.

### Plan Requirement

For best reliability, keep the default Apify residential proxy setting. `maxItems` is a maximum cap, not a guaranteed count; a run can save fewer rows when the selected location, URL, keyword, and filters match fewer active jobs.

# Actor input Schema

## `mode` (type: `string`):

Search mode builds Wellfound location pages from the locations field. URL mode reads the pasted Wellfound URLs.

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

Wellfound location slugs or names. Examples: san-francisco, new-york, london. Each location is searched separately.

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

Paste Wellfound /jobs or /location/... URLs. Multi-URL supported. Pagination starts at the page in the URL.

## `keywords` (type: `array`):

Only keep jobs where at least one keyword appears in the title, company, role, location, badges, compensation, or description text.

## `roleKeywords` (type: `array`):

Only keep jobs whose title or primary role contains at least one of these values. Examples: engineer, product, sales.

## `remoteOnly` (type: `boolean`):

Only keep jobs marked as remote or with remote configuration data.

## `requireCompensation` (type: `boolean`):

Only keep jobs with a compensation value.

## `activelyHiringOnly` (type: `boolean`):

Only keep jobs attached to companies marked as actively hiring in the listing data.

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

Maximum number of matching job rows to save. The run can return fewer rows when the selected location, URL, keyword, and filters match fewer current jobs.

## `maxPages` (type: `integer`):

Maximum Wellfound pages to read per location or pasted URL. Defaults to the highest allowed value because max items is the primary output cap.

## `proxy` (type: `object`):

Uses Apify Proxy residential by default. Leave as-is unless your account or run environment requires another route.

## `mcpConnectors` (type: `array`):

Optionally send the scraped jobs into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify > Settings > API & Integrations, then select it here. Notion gets a page-per-job export; other connectors receive a best-effort write or digest. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which job pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on how many jobs are written to each selected connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "locations": [
    "san-francisco"
  ],
  "startUrls": [
    {
      "url": "https://wellfound.com/location/san-francisco"
    },
    {
      "url": "https://wellfound.com/jobs"
    }
  ],
  "keywords": [
    "python"
  ],
  "remoteOnly": false,
  "requireCompensation": false,
  "activelyHiringOnly": false,
  "maxItems": 20,
  "maxPages": 50,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (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 = {
    "locations": [
        "san-francisco"
    ],
    "startUrls": [
        {
            "url": "https://wellfound.com/location/san-francisco"
        },
        {
            "url": "https://wellfound.com/jobs"
        }
    ],
    "keywords": [
        "python"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/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 = {
    "locations": ["san-francisco"],
    "startUrls": [
        { "url": "https://wellfound.com/location/san-francisco" },
        { "url": "https://wellfound.com/jobs" },
    ],
    "keywords": ["python"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/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 '{
  "locations": [
    "san-francisco"
  ],
  "startUrls": [
    {
      "url": "https://wellfound.com/location/san-francisco"
    },
    {
      "url": "https://wellfound.com/jobs"
    }
  ],
  "keywords": [
    "python"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call abotapi/wellfound-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wellfound Scraper – Startup Jobs, Remote Roles & Compensation",
        "description": "Extract startup job listings from Wellfound.com with location, keyword, role, remote, compensation, company badge, and MCP connector export options.",
        "version": "0.1",
        "x-build-id": "4fSCuu0bBmEhHAbdN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~wellfound-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-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/abotapi~wellfound-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-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/abotapi~wellfound-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Input mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "Search mode builds Wellfound location pages from the locations field. URL mode reads the pasted Wellfound URLs.",
                        "default": "search"
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Wellfound location slugs or names. Examples: san-francisco, new-york, london. Each location is searched separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Wellfound URLs",
                        "type": "array",
                        "description": "Paste Wellfound /jobs or /location/... URLs. Multi-URL supported. Pagination starts at the page in the URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Only keep jobs where at least one keyword appears in the title, company, role, location, badges, compensation, or description text.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "roleKeywords": {
                        "title": "Role keywords",
                        "type": "array",
                        "description": "Only keep jobs whose title or primary role contains at least one of these values. Examples: engineer, product, sales.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Only keep jobs marked as remote or with remote configuration data.",
                        "default": false
                    },
                    "requireCompensation": {
                        "title": "Require compensation",
                        "type": "boolean",
                        "description": "Only keep jobs with a compensation value.",
                        "default": false
                    },
                    "activelyHiringOnly": {
                        "title": "Actively hiring only",
                        "type": "boolean",
                        "description": "Only keep jobs attached to companies marked as actively hiring in the listing data.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of matching job rows to save. The run can return fewer rows when the selected location, URL, keyword, and filters match fewer current jobs.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Max pages per source",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum Wellfound pages to read per location or pasted URL. Defaults to the highest allowed value because max items is the primary output cap.",
                        "default": 50
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Uses Apify Proxy residential by default. Leave as-is unless your account or run environment requires another route."
                    },
                    "mcpConnectors": {
                        "title": "Pipe results into your apps (optional)",
                        "type": "array",
                        "description": "Optionally send the scraped jobs into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify > Settings > API & Integrations, then select it here. Notion gets a page-per-job export; other connectors receive a best-effort write or digest. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com)."
                    },
                    "notionParentPageUrl": {
                        "title": "Notion parent page",
                        "type": "string",
                        "description": "URL or id of the Notion page under which job pages are created. Required to enable the Notion export; ignored by other connectors."
                    },
                    "maxNotifyListings": {
                        "title": "Max jobs to export per connector",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on how many jobs are written to each selected connector per run. Does not affect the dataset.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
