# Y Combinator Jobs Scraper (`fetch_cat/y-combinator-jobs-scraper`) Actor

Scrape public YC Work at a Startup jobs with roles, locations, remote flags, salary, equity, company details, apply links, and descriptions.

- **URL**: https://apify.com/fetch\_cat/y-combinator-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 result extracteds

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

## Y Combinator Jobs Scraper

Scrape public YC Work at a Startup job listings from Y Combinator companies.

Use this actor to collect startup job titles, roles, locations, remote flags, compensation ranges, equity, experience requirements, apply links, company names, YC batches, and optional long job descriptions.

### What does Y Combinator Jobs Scraper do?

Y Combinator Jobs Scraper extracts public job postings from the YC jobs board.

It turns the YC hiring marketplace into a structured dataset you can export to JSON, CSV, Excel, Google Sheets, or your own database.

Typical output includes:

- 🧑‍💻 Job title
- 🏢 Company name
- 🚀 YC batch
- 🌎 Location
- 🏠 Remote availability
- 💰 Salary range
- 📈 Equity range
- 🧰 Role category
- 📝 Experience requirement
- 🔗 Job URL
- ✅ Apply URL

### Who is it for?

Recruiters use it to monitor fast-growing startup hiring demand.

Founders use it to benchmark compensation and understand how other YC companies hire.

Sales teams use it to spot companies that are scaling specific functions.

Job-market analysts use it to track role demand, remote hiring patterns, and startup compensation trends.

Developers use it to power dashboards, alerts, and internal search tools.

### Why scrape YC jobs?

YC companies are often early indicators of startup hiring trends.

The jobs board includes roles from venture-backed companies across AI, SaaS, fintech, healthcare, developer tools, marketplaces, and more.

Structured YC job data helps you answer questions such as:

- Which YC startups are hiring engineers right now?
- Which companies are remote-friendly?
- What salary ranges are common for startup roles?
- Which batches are most actively hiring?
- Which cities have the most YC startup jobs?
- Which companies are hiring sales, marketing, or operations teams?

### Key features

- 🔎 Keyword search across visible listing text
- 🧑‍💻 Role filters such as Engineering, Product, Sales, Marketing, Support, Operations, Design, and Science
- 🌎 Location filters such as Remote, San Francisco, New York, Los Angeles, Seattle, Austin, Chicago, and India
- 🏠 Remote-only filter
- 📊 Compensation and equity fields
- 📝 Optional detail-page enrichment for long descriptions
- ⚡ HTTP-based extraction for fast, low-cost runs
- 📦 Clean single-dataset output
- ✅ Pay-per-result pricing

### How much does it cost to scrape YC jobs?

This actor uses pay-per-event pricing.

You pay a small start fee and a per-result fee for each YC job posting saved to the dataset.

For a small run of 25 results, the expected actor charge is low and suitable for testing.

For larger monitoring jobs, use `maxResults` to control spend.

The exact live price is shown on the Apify actor page before you start a run.

### Input options

The input is designed for quick first runs and repeatable monitoring.

#### `searchQuery`

Optional keyword filter.

Examples:

- `engineer`
- `founding`
- `sales`
- `AI`
- `intern`

#### `roles`

Optional list of role categories or YC role labels.

Examples:

- `Engineering`
- `Product`
- `Sales`
- `Marketing`
- `Operations`
- `Support`
- `Design`
- `Science`

#### `locations`

Optional list of location filters.

Examples:

- `Remote`
- `San Francisco`
- `New York`
- `Los Angeles`
- `Seattle`
- `Austin`
- `Chicago`
- `India`

#### `remoteOnly`

Set to `true` to save only jobs marked as remote or with remote in the location.

#### `minExperience`

Optional minimum years of experience.

Jobs without a numeric experience requirement remain included because many YC listings use text such as “Any” or “new grads ok”.

#### `maxResults`

Maximum number of matching jobs to save.

Start small while testing.

Increase it for production monitoring.

#### `includeCompanyDetails`

When enabled, the actor visits matching job pages to add the long job description.

Keep it disabled for the fastest and cheapest runs.

Enable it when you need full job descriptions for analysis or search indexing.

### Example input

```json
{
  "searchQuery": "engineer",
  "roles": ["Engineering"],
  "locations": ["Remote"],
  "remoteOnly": true,
  "maxResults": 25,
  "includeCompanyDetails": false
}
````

### Output data

Each dataset row is one YC job posting.

| Field | Description |
| --- | --- |
| `jobId` | YC job identifier |
| `title` | Job title |
| `role` | Broad role label |
| `roleSpecificType` | Specific role subtype when available |
| `companyName` | YC company name |
| `companyUrl` | YC company profile URL |
| `ycBatch` | YC batch, such as W24 or S23 |
| `location` | Listed job location |
| `remote` | Whether the job appears remote |
| `type` | Job type, such as Full-time |
| `salaryRange` | Listed salary range |
| `equityRange` | Listed equity range |
| `minExperience` | Listed experience requirement |
| `description` | Long description when detail enrichment is enabled |
| `applyUrl` | Application URL |
| `jobUrl` | YC job detail URL |
| `scrapedAt` | ISO timestamp for the run |

### Example output

```json
{
  "jobId": "97116",
  "title": "Product Marketing",
  "role": "Marketing",
  "companyName": "Text Blaze",
  "ycBatch": "W21",
  "location": "San Francisco / Remote (US)",
  "remote": true,
  "type": "Full-time",
  "salaryRange": "$80K - $150K",
  "equityRange": "0.50%",
  "minExperience": "Any (new grads ok)",
  "applyUrl": "https://account.ycombinator.com/...",
  "jobUrl": "https://www.ycombinator.com/companies/text-blaze/jobs/...",
  "scrapedAt": "2026-07-06T08:52:05.171Z"
}
```

### How to run it

1. Open the actor on Apify.
2. Enter a keyword, role, or location filter.
3. Set `maxResults` to your preferred limit.
4. Decide whether you need long descriptions.
5. Click **Start**.
6. Export the dataset when the run finishes.

### Tips for best results

Use a broad role filter first, then narrow by keyword.

Use `remoteOnly` when you only need remote roles.

Disable detail enrichment for scheduled monitoring runs.

Enable detail enrichment when feeding results into a search index or LLM workflow.

Set `maxResults` to a low number for test runs.

### Common workflows

#### Startup hiring monitor

Run daily with `roles: ["Engineering"]` and export results to a spreadsheet.

#### Remote YC job tracker

Run with `locations: ["Remote"]` and `remoteOnly: true`.

#### Compensation benchmark

Export salary and equity fields for selected roles.

#### Sales trigger list

Track companies hiring sales, support, or operations roles as growth signals.

#### Talent market research

Analyze role mix by YC batch, city, or remote status.

### Integrations

You can connect results to:

- Google Sheets
- Airtable
- Slack alerts
- Notion databases
- HubSpot or Salesforce enrichment flows
- Internal recruiting dashboards
- Data warehouses
- Vector databases for semantic job search

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/y-combinator-jobs-scraper').call({
  roles: ['Engineering'],
  locations: ['Remote'],
  remoteOnly: true,
  maxResults: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('fetch_cat/y-combinator-jobs-scraper').call(run_input={
    'roles': ['Engineering'],
    'locations': ['Remote'],
    'remoteOnly': True,
    'maxResults': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~y-combinator-jobs-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"roles":["Engineering"],"locations":["Remote"],"remoteOnly":true,"maxResults":25}'
```

### MCP usage

Use this actor from MCP-compatible tools through the Apify MCP server.

MCP URL pattern:

```text
https://mcp.apify.com/?tools=fetch_cat/y-combinator-jobs-scraper
```

#### Claude Code MCP CLI setup

```bash
claude mcp add apify-yc-jobs "https://mcp.apify.com/?tools=fetch_cat/y-combinator-jobs-scraper"
```

#### MCP JSON configuration

```json
{
  "mcpServers": {
    "apify-yc-jobs": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/y-combinator-jobs-scraper"
    }
  }
}
```

Example prompts:

- “Find remote engineering jobs from YC companies and summarize salary ranges.”
- “Which YC companies are hiring product managers in New York?”
- “Create a table of startup sales roles with equity ranges.”
- “Monitor new YC remote jobs and draft a Slack update.”

### Scheduling

You can schedule the actor to run daily or weekly.

For monitoring workflows, use stable filters and a practical `maxResults` limit.

Export or integrate the dataset after every run.

### Data freshness

The actor reads the public YC jobs board at run time.

Results reflect what was visible during the run.

If a company removes or edits a job, future runs may return different data.

### Limitations

The actor can only return public jobs visible on YC pages.

Some listings may omit salary, equity, role subtype, or experience details.

Application links may point through YC account pages.

Long descriptions require detail enrichment and therefore take longer.

### FAQ

#### Can I scrape remote-only YC jobs?

Yes. Set `remoteOnly` to `true` and optionally add `Remote` to `locations`.

#### Can I get long job descriptions?

Yes. Enable `includeCompanyDetails`, which adds detail-page descriptions for matching jobs.

### Troubleshooting

#### Why did I get zero results?

Your filters may be too narrow.

Remove `searchQuery`, reduce role/location filters, or increase `maxResults`.

#### Why is `description` null?

Enable `includeCompanyDetails` to fetch job detail pages and fill long descriptions.

#### Why are some compensation fields empty?

YC companies do not always publish salary or equity ranges for every job.

#### Why do I see fewer results than `maxResults`?

The source may have fewer jobs matching your filters at run time.

### Legality and responsible use

This actor extracts publicly available information from YC job pages.

Use the data responsibly and respect applicable laws, platform terms, and privacy obligations.

Do not use scraped data for spam, harassment, discrimination, or prohibited employment practices.

### Related actors

Explore related Apify actors from the same publisher:

- https://apify.com/fetch\_cat/y-combinator-companies-scraper
- https://apify.com/fetch\_cat/dice-jobs-scraper
- https://apify.com/fetch\_cat/ashby-jobs-scraper
- https://apify.com/fetch\_cat/ats-jobs-scraper
- https://apify.com/fetch\_cat/craigslist-classifieds-scraper

### Support

If a run fails or the output looks wrong, open an issue with your run URL and input.

Include whether detail enrichment was enabled.

### Changelog

Initial version extracts public YC job listings with filters for keyword, role, location, remote-only jobs, experience, result limit, and optional descriptions.

# Actor input Schema

## `searchQuery` (type: `string`):

Optional keyword filter across job titles, company names, roles, locations, and compensation text.

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

Optional YC role labels or codes to include, such as Engineering, Product, Sales, Marketing, Operations, or Design.

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

Optional location text filters, for example Remote, San Francisco, New York, London, or India.

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

Only save jobs whose YC listing is marked Remote or has Remote in the location.

## `minExperience` (type: `integer`):

Optional lower bound. For example, 3 keeps jobs listed as 3+ years, 5+ years, etc. Jobs with no numeric experience remain included.

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

Maximum number of matching YC job postings to save.

## `includeCompanyDetails` (type: `boolean`):

When enabled, the actor visits each matching job page to add long job descriptions. Keep disabled for the fastest and cheapest runs.

## Actor input object example

```json
{
  "searchQuery": "engineer",
  "roles": [
    "Engineering"
  ],
  "locations": [
    "Remote"
  ],
  "remoteOnly": false,
  "maxResults": 20,
  "includeCompanyDetails": false
}
```

# 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 = {
    "searchQuery": "engineer",
    "roles": [
        "Engineering"
    ],
    "locations": [
        "Remote"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/y-combinator-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 = {
    "searchQuery": "engineer",
    "roles": ["Engineering"],
    "locations": ["Remote"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/y-combinator-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 '{
  "searchQuery": "engineer",
  "roles": [
    "Engineering"
  ],
  "locations": [
    "Remote"
  ],
  "maxResults": 20
}' |
apify call fetch_cat/y-combinator-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Y Combinator Jobs Scraper",
        "description": "Scrape public YC Work at a Startup jobs with roles, locations, remote flags, salary, equity, company details, apply links, and descriptions.",
        "version": "0.1",
        "x-build-id": "g1r95YMAvvblhJLiX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~y-combinator-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-y-combinator-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/fetch_cat~y-combinator-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-y-combinator-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/fetch_cat~y-combinator-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-y-combinator-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": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Optional keyword filter across job titles, company names, roles, locations, and compensation text."
                    },
                    "roles": {
                        "title": "Roles",
                        "type": "array",
                        "description": "Optional YC role labels or codes to include, such as Engineering, Product, Sales, Marketing, Operations, or Design.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional location text filters, for example Remote, San Francisco, New York, London, or India.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "remoteOnly": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "Only save jobs whose YC listing is marked Remote or has Remote in the location.",
                        "default": false
                    },
                    "minExperience": {
                        "title": "Minimum years of experience",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Optional lower bound. For example, 3 keeps jobs listed as 3+ years, 5+ years, etc. Jobs with no numeric experience remain included."
                    },
                    "maxResults": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of matching YC job postings to save.",
                        "default": 50
                    },
                    "includeCompanyDetails": {
                        "title": "Fetch job detail pages",
                        "type": "boolean",
                        "description": "When enabled, the actor visits each matching job page to add long job descriptions. Keep disabled for the fastest and cheapest runs.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```