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

Collect startup & tech job listings from Wellfound (AngelList Talent) by role, location, remote, or company — with full descriptions, pay, equity, company size, funding, and hiring badges. No login.

- **URL**: https://apify.com/xtracto/wellfound-jobs-scraper.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $80.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Startup Jobs Scraper

Collect startup and tech job listings from **Wellfound** (formerly AngelList Talent) — by role, location, remote, or company — with full job descriptions, pay ranges, equity, company size, funding signals, and hiring badges. No account or login required.

### Why use this actor

- **No login or account needed** — works on public job pages.
- **Full job descriptions included** — not just titles. Every job comes with its complete description, pay range, and location.
- **Rich company context** — each job carries the company name, size, one-line pitch, and hiring badges (Actively Hiring, Responds Quickly, Growing Fast, Top Investors, Y Combinator, and more).
- **Flexible targeting** — search by role, by city/state/country, remote-only, or pull every opening from specific companies.
- **Built-in filters** — narrow by job type, date posted, and keyword without extra work.
- **Stable JSON output** — clean, consistent records ready for spreadsheets, databases, or hiring/market dashboards.
- **Handles site protection automatically** — you don't manage browsers, sessions, or retries.

### How it works

1. You choose what to collect: one or more **roles** (e.g. `software-engineer`), **locations** (e.g. `new-york`, `united-states`), a **remote-only** toggle, and/or specific **companies**.
2. Optionally add filters: **job type**, **date posted**, and a **keyword**.
3. The actor opens the matching Wellfound pages, reads every job on them, and turns the next pages automatically until it reaches your limit.
4. Each job becomes one row in your dataset — downloadable as JSON, CSV, or Excel.

You don't need to manage proxies-per-page, sessions, or page-turning logic — just press Run. A residential proxy (US recommended) should be enabled, which is the default.

### Use cases

- **Recruiting & sourcing** — build fresh lists of startups hiring for a given role or city.
- **Sales & lead gen** — find companies that are actively hiring (a growth signal) and reach the right teams.
- **Market & talent research** — track which roles, pay ranges, and locations are in demand across the startup ecosystem.
- **Competitive hiring intelligence** — monitor specific companies' open roles over time.
- **Job boards & aggregators** — feed startup roles into your own product.

### Input

```json
{
  "roles": ["software-engineer"],
  "locations": ["new-york"],
  "companySlugs": [],
  "remoteOnly": false,
  "jobTypes": ["full-time"],
  "datePosted": "month",
  "keyword": "",
  "maxItemsPerQuery": 0,
  "maxItems": 0,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
````

| Field | Type | Description |
|---|---|---|
| `roles` | array | Roles to collect, as Wellfound slugs (lowercase, dash-separated), e.g. `software-engineer`, `product-manager`, `designer`, `data-scientist`. Combine with `locations` for role-in-city results. |
| `locations` | array | Cities, states, or countries **by name** (not a country code), e.g. `new-york`, `san-francisco`, `london`, `california`, `united-states`, `india`. Type any location Wellfound supports. |
| `companySlugs` | array | Optional. Pull every opening from specific companies. Use the handle from the company's page URL (`wellfound.com/company/THIS-PART`), e.g. `stripe`, `openai`. |
| `remoteOnly` | boolean | Keep only roles that can be done remotely. Default `false`. |
| `jobTypes` | array | Keep only these employment types: `full-time`, `part-time`, `contract`, `internship`, `cofounder`. Empty = all. |
| `datePosted` | string | Keep only jobs posted within: `any`, `today`, `3days`, `week`, `month`. Default `any`. |
| `keyword` | string | Optional. Keep only jobs whose title or description contains this text (e.g. `python`, `react`, `senior`). |
| `maxItemsPerQuery` | integer | Cap jobs per role/location/company. `0` = all available. |
| `maxItems` | integer | Overall cap for the whole run. `0` = no limit. |
| `proxyConfiguration` | object | Residential proxy is required; US is recommended (the default). |

You must provide at least one of `roles`, `locations`, or `companySlugs`.

### Output

One record per job:

```json
{
  "_input": "role:software-engineer",
  "_scrapedAt": "2026-06-16T12:03:43Z",
  "recordType": "JOB_LISTING",
  "jobId": "4322508",
  "title": "Software Engineer",
  "slug": "software-engineer",
  "jobType": "full-time",
  "compensation": "$150k – $185k",
  "equity": null,
  "remote": true,
  "locationNames": ["New York City"],
  "acceptedRemoteLocationNames": ["United States"],
  "primaryRoleTitle": "Software Engineer",
  "yearsExperienceMin": null,
  "yearsExperienceMax": null,
  "atsSource": "AtsIntegration::Ashby::Listing",
  "liveStartAt": 1781047549,
  "description": "**Come join our Engineering team!** ... (full description, truncated here)",
  "jobUrl": "https://wellfound.com/company/futurefit-ai-2/jobs/4322508-software-engineer",
  "startup": {
    "id": "8030547",
    "name": "FutureFit AI",
    "slug": "futurefit-ai-2",
    "companySize": "SIZE_11_50",
    "highConcept": "AI-powered GPS for your Career",
    "logoUrl": "https://photos.wellfound.com/startups/i/8030547-...-medium_jpg.jpg",
    "badges": [
      { "id": "ACTIVELY_HIRING", "label": "Actively Hiring", "tooltip": "Actively processing applications" },
      { "id": "QUICK_RESPONDER-8030547", "label": "Responds within two weeks" },
      { "id": "B2B-8030547", "label": "B2B" },
      { "id": "COMPANY_STAGE-8030547", "label": "Early Stage", "data": "early_stage" }
      // ... more
    ]
  }
}
```

| Field | Type | Description |
|---|---|---|
| `_input` | string | The query that produced this record (e.g. `role:software-engineer`). |
| `_scrapedAt` | string | UTC timestamp when the record was collected. |
| `recordType` | string | Always `JOB_LISTING`. |
| `jobId` | string | Wellfound's job ID. |
| `title` | string | Job title. |
| `jobType` | string | `full-time`, `part-time`, `contract`, `internship`, or `cofounder`. |
| `compensation` | string | Pay range as shown (e.g. `$150k – $185k`), if listed. |
| `equity` | string | Equity range, if listed. |
| `remote` | boolean | Whether the role can be done remotely. |
| `locationNames` | array | Listed work locations. |
| `acceptedRemoteLocationNames` | array | Remote regions accepted, if any. |
| `primaryRoleTitle` | string | The role category Wellfound assigns. |
| `yearsExperienceMin` / `Max` | number | Experience range, if listed. |
| `atsSource` | string | The hiring system the listing came through (a useful company signal). |
| `liveStartAt` | number | When the job went live (Unix seconds). |
| `description` | string | The full job description. |
| `jobUrl` | string | Direct link to the job on Wellfound. |
| `startup` | object | Company details: `name`, `slug`, `companySize`, `highConcept` (one-line pitch), `logoUrl`, and `badges` (hiring signals). |

Records that fail (e.g. an unknown role/location slug) are returned with an `_error` field instead of job data, so nothing fails silently.

### Notes

- **Location is a name, not a country code** — use `united-states`, not `US`.
- **Job type, date posted, and keyword** are applied as filters on the collected jobs.
- A startup that has several matching jobs may appear under more than one job row — each job is its own record, de-duplicated by job ID within a query.

# Actor input Schema

## `roles` (type: `array`):

Job roles to collect, one per line, as Wellfound slugs (lowercase, dash-separated). Examples: software-engineer, product-manager, designer, data-scientist, marketing, sales, machine-learning-engineer. Combine with Locations to get role + city/country results. Leave empty to scrape by Location or Company only.

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

Cities, states, or countries by NAME (not country code), one per line, as Wellfound slugs. Examples: new-york, san-francisco, london, california, united-states, india, remote. You can type any location Wellfound supports. Leave empty for all locations.

## `companySlugs` (type: `array`):

Scrape jobs from specific companies. Use the company handle from its Wellfound page URL (wellfound.com/company/THIS-PART), e.g. stripe, openai, ramp. Each company's current openings are collected.

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

Keep only roles that can be done remotely.

## `jobTypes` (type: `array`):

Keep only these employment types. Leave empty to include all.

## `datePosted` (type: `string`):

Keep only jobs posted within this window.

## `keyword` (type: `string`):

Keep only jobs whose title or description contains this text (case-insensitive). Example: python, react, senior.

## `maxItemsPerQuery` (type: `integer`):

Cap the number of jobs collected per role/location/company. 0 means collect everything available.

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

Overall cap across all roles, locations, and companies in this run. 0 means no overall limit.

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

Residential proxy is REQUIRED for this source. US is recommended.

## Actor input object example

```json
{
  "roles": [
    "software-engineer"
  ],
  "locations": [],
  "companySlugs": [],
  "remoteOnly": false,
  "jobTypes": [],
  "datePosted": "any",
  "keyword": "",
  "maxItemsPerQuery": 0,
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "roles": [
        "software-engineer"
    ],
    "locations": [],
    "companySlugs": [],
    "jobTypes": [],
    "keyword": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/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 = {
    "roles": ["software-engineer"],
    "locations": [],
    "companySlugs": [],
    "jobTypes": [],
    "keyword": "",
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/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 '{
  "roles": [
    "software-engineer"
  ],
  "locations": [],
  "companySlugs": [],
  "jobTypes": [],
  "keyword": ""
}' |
apify call xtracto/wellfound-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wellfound Startup Jobs Scraper",
        "description": "Collect startup & tech job listings from Wellfound (AngelList Talent) by role, location, remote, or company — with full descriptions, pay, equity, company size, funding, and hiring badges. No login.",
        "version": "0.1",
        "x-build-id": "9ggtqYPc6aJcIK7bL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~wellfound-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-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/xtracto~wellfound-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-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/xtracto~wellfound-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-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": {
                    "roles": {
                        "title": "Roles",
                        "type": "array",
                        "description": "Job roles to collect, one per line, as Wellfound slugs (lowercase, dash-separated). Examples: software-engineer, product-manager, designer, data-scientist, marketing, sales, machine-learning-engineer. Combine with Locations to get role + city/country results. Leave empty to scrape by Location or Company only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations (type your own)",
                        "type": "array",
                        "description": "Cities, states, or countries by NAME (not country code), one per line, as Wellfound slugs. Examples: new-york, san-francisco, london, california, united-states, india, remote. You can type any location Wellfound supports. Leave empty for all locations.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companySlugs": {
                        "title": "Company pages (optional)",
                        "type": "array",
                        "description": "Scrape jobs from specific companies. Use the company handle from its Wellfound page URL (wellfound.com/company/THIS-PART), e.g. stripe, openai, ramp. Each company's current openings are collected.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "remoteOnly": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "Keep only roles that can be done remotely.",
                        "default": false
                    },
                    "jobTypes": {
                        "title": "Job types",
                        "type": "array",
                        "description": "Keep only these employment types. Leave empty to include all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "full-time",
                                "part-time",
                                "contract",
                                "internship",
                                "cofounder"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Contract",
                                "Internship",
                                "Co-founder"
                            ]
                        }
                    },
                    "datePosted": {
                        "title": "Date posted",
                        "enum": [
                            "any",
                            "today",
                            "3days",
                            "week",
                            "month"
                        ],
                        "type": "string",
                        "description": "Keep only jobs posted within this window.",
                        "default": "any"
                    },
                    "keyword": {
                        "title": "Keyword (optional)",
                        "type": "string",
                        "description": "Keep only jobs whose title or description contains this text (case-insensitive). Example: python, react, senior.",
                        "default": ""
                    },
                    "maxItemsPerQuery": {
                        "title": "Max jobs per role/location (0 = all)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the number of jobs collected per role/location/company. 0 means collect everything available.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Max jobs total (0 = all)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Overall cap across all roles, locations, and companies in this run. 0 means no overall limit.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Residential proxy is REQUIRED for this source. US is recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
