# Startup.jobs Scraper (`parsebird/startup-jobs-scraper`) Actor

Extract job listings from Startup.jobs — titles, companies, salaries, locations, descriptions, and application links. Filter by keyword and location. Export as JSON, CSV, Excel. Pay per result.

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

## Pricing

from $1.00 / 1,000 listing scrapeds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Startup.jobs Scraper — Extract Job Listings, Salaries & Company Data

Extract structured job listings from [Startup.jobs](https://startup.jobs) — the leading startup job board with thousands of active postings from fast-growing technology companies. Search by keyword, location, and workplace type. Get job titles, company details, salary ranges, descriptions, and application links. Export as JSON, CSV, or Excel.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search by keyword and location, collect up to 500 job listings per run with 24 structured data fields — including salary ranges, job descriptions, employment type, company info, and direct application links. Two-tier pricing: $1/1,000 for listings, $1.50/1,000 with full details.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

````

Apify Actor: parsebird/startup-jobs-scraper — extracts job listings from Startup.jobs. $0.001/listing ($1/1000) or $0.0015/detail ($1.50/1000). Call via ApifyClient: client.actor("parsebird/startup-jobs-scraper").call(run\_input={"keyword": "software engineer", "location": "Remote", "collectDetails": False, "results\_wanted": 20}). Inputs: keyword (string, search term), location (string, default "Remote"), startUrl (string, optional override URL), collectDetails (boolean, default false, fetch full descriptions), results\_wanted (integer, default 20, max 500). Output: dataset with id, title, company, location, job\_type, salary, posted\_at, description\_text, description\_html, company\_logo, apply\_link, url, tags, workplace\_type, employment\_type, salary\_min, salary\_max, salary\_currency, city, country, company\_slug, fetched\_at. API docs: https://docs.apify.com/api/v2 Token: https://console.apify.com/settings/integrations

````

### What is Startup.jobs Scraper?

**Startup.jobs Scraper** is an [Apify Actor](https://apify.com/actors) that extracts job listings from [Startup.jobs](https://startup.jobs) — a popular job board focused on startup and technology companies. It collects structured data including job titles, company names, salary ranges, locations, full job descriptions, and application links.

This actor uses a **hybrid approach** — a stealth browser bypasses Cloudflare protection and captures API credentials, then queries the Algolia search API directly for fast, paginated results. When `collectDetails` is enabled, detail pages are enriched via browser for full descriptions and apply links. Clean, structured data ready for analysis, monitoring, or integration.

Startup.jobs Scraper is a cost-effective alternative to building your own [Startup.jobs](https://startup.jobs) data pipeline — no coding, infrastructure, or maintenance required.

### What can Startup.jobs Scraper do?

- 🔍 **Keyword search** — Find jobs by role, skill, or technology (e.g. "software engineer", "product manager", "data scientist")
- 📍 **Location filtering** — Filter by "Remote" for remote-first positions, or search all locations
- 📄 **Full description enrichment** — Optionally fetch complete job descriptions and application links from detail pages
- 💰 **Salary data** — Extract salary ranges with currency and interval when published by employers
- 🏢 **Company details** — Company name, logo URL, and slug for each listing
- 🏷️ **Tags and categories** — Role tags, employment type, workplace type, and experience level
- ⚡ **Fast hybrid extraction** — Algolia API for listings, browser for detail enrichment
- 📊 **Up to 500 results per run** — Automatic pagination through listing pages
- 🔗 **Direct application links** — Get the apply URL for each job listing (with `collectDetails`)
- 📅 **Scheduling support** — Set up [recurring runs](https://docs.apify.com/platform/schedules) to monitor new job postings daily or weekly

### What data can you extract from Startup.jobs?

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique job identifier from Startup.jobs |
| `title` | string | Job title (e.g. "Senior Full Stack Engineer") |
| `company` | string | Hiring company name |
| `location` | string | Job location or remote status |
| `job_type` | string | Employment type — Full Time, Part Time, Contract, Internship |
| `salary` | string | Formatted salary range (e.g. "USD 150,000 - 200,000 per year") |
| `posted_at` | string | Job publish timestamp (ISO 8601) |
| `description_text` | string | Plain text job description (when `collectDetails` is enabled) |
| `description_html` | string | Rich HTML job description (when `collectDetails` is enabled) |
| `company_logo` | string | Company logo image URL |
| `apply_link` | string | Direct application URL (when `collectDetails` is enabled) |
| `url` | string | Job listing page URL on Startup.jobs |
| `tags` | array | Role and topic tags (e.g. ["Engineer", "Full Stack", "Senior"]) |
| `workplace_type` | string | Remote, Hybrid, or On-site |
| `salary_min` / `salary_max` | number | Numeric salary bounds for analysis |
| `salary_currency` | string | Currency code (USD, EUR, GBP, etc.) |
| `city` / `country` | string | Structured location fields |
| `company_slug` | string | Company URL slug on Startup.jobs |

### How to scrape Startup.jobs

1. **Go to** [Startup.jobs Scraper](https://apify.com/parsebird/startup-jobs-scraper) on Apify Store and click **Try for free**
2. **Enter a search keyword** — type a job title, skill, or role you're looking for (e.g. "software engineer")
3. **Set the location** — enter "Remote" for remote jobs, or leave it to get all locations (default: Remote)
4. **Choose whether to collect details** — enable "Collect Job Details" to get full descriptions and apply links (disabled by default to keep costs low)
5. **Set your limit** — adjust "Max Results" (default 20, max 500)
6. **Click Start** — the scraper begins extracting job listings immediately
7. **Download your data** — export results as JSON, CSV, Excel, or access them via the [Apify API](https://docs.apify.com/api/v2)

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrl` | string | No | — | Custom Startup.jobs listing URL. Overrides keyword and location filters when provided |
| `keyword` | string | No | `""` | Search phrase — job title, skill, or role keywords |
| `location` | string | No | `"Remote"` | Location filter. Use "Remote" for remote jobs, or enter a city/country |
| `collectDetails` | boolean | No | `false` | Fetch full job descriptions and application links from detail pages. Costs $1.50/1,000 vs $1/1,000 without |
| `results_wanted` | integer | No | `20` | Maximum number of job listings to collect (1–500) |

### Output example

```json
{
    "id": "6654883",
    "title": "Senior Full Stack Engineer",
    "company": "Solace",
    "location": "Remote",
    "job_type": "Full Time",
    "salary": "USD 150,000 - 200,000 per year",
    "posted_at": "2026-01-22T16:50:47Z",
    "description_text": "As a Full Stack Engineer, you'll join a talented team and own delivery from requirements through release...",
    "description_html": "<div class=\"trix-content\">...</div>",
    "company_logo": "https://startup.jobs/logos/34127",
    "apply_link": "https://startup.jobs/apply/4cec53b4-9d8e-4ce7-989b-b9f0e163de13",
    "url": "https://startup.jobs/senior-full-stack-engineer-solace-6654883",
    "source": "listing+details",
    "fetched_at": "2026-02-14T05:28:50.151Z",
    "tags": ["Engineer", "Full Stack", "Senior"],
    "workplace_type": "Remote",
    "employment_type": "full-time",
    "experience_bucket": null,
    "salary_min": 150000,
    "salary_max": 200000,
    "salary_currency": "USD",
    "city": null,
    "country": "United States",
    "company_slug": "solace"
}
````

### How to use Startup.jobs Scraper with the API

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("parsebird/startup-jobs-scraper").call(run_input={
    "keyword": "software engineer",
    "location": "Remote",
    "collectDetails": False,
    "results_wanted": 50,
})

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    salary = job.get("salary") or "Not listed"
    print(f"{job['title']} at {job['company']} — {salary}")
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('parsebird/startup-jobs-scraper').call({
    keyword: 'software engineer',
    location: 'Remote',
    collectDetails: false,
    results_wanted: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(job => {
    const salary = job.salary || 'Not listed';
    console.log(`${job.title} at ${job.company} — ${salary}`);
});
```

### How much does it cost to scrape Startup.jobs?

Startup.jobs Scraper uses [Pay-Per-Event pricing](https://docs.apify.com/platform/actors/running/pay-per-event) with two tiers depending on whether you collect job details.

| Event | What you get | Price per event | Price per 1,000 |
|-------|-------------|----------------|-----------------|
| `listing-scraped` | Job title, company, salary, location, tags, URL | $0.001 | **$1.00** |
| `detail-scraped` | Everything above + full description, HTML, apply link | $0.0015 | **$1.50** |

**Typical costs (listings only, `collectDetails: false`):**

- 20 jobs (default run): **~$0.02**
- 100 jobs: **~$0.10**
- 500 jobs (max per run): **~$0.50**

**Typical costs (with details, `collectDetails: true`):**

- 20 jobs: **~$0.03**
- 100 jobs: **~$0.15**
- 500 jobs: **~$0.75**

New Apify users get a **free trial** with $5 of platform credits — enough to scrape thousands of job listings at no cost.

### Use cases

- **Talent intelligence** — Track hiring demand across startup roles, locations, and seniority levels. Build weekly trend snapshots for leadership and recruiting teams
- **Recruitment operations** — Automate candidate sourcing by collecting new openings and role attributes. Reduce manual job-board monitoring effort
- **Compensation research** — Analyze salary ranges by function, seniority, and market. Support compensation benchmarking with structured salary data
- **Job alert platforms** — Feed job records into internal dashboards, notification systems, or matching algorithms
- **Market research** — Monitor role requirements, tech stacks, and company hiring patterns over time. Identify trends in startup hiring strategies
- **Academic research** — Study startup labor market dynamics, remote work adoption, and salary distribution patterns

### Integrations and export formats

Connect Startup.jobs Scraper output with your existing tools:

- **[Google Sheets](https://apify.com/integrations/google-sheets)** — Automatically sync job data to a spreadsheet for team collaboration
- **[Airtable](https://apify.com/integrations/airtable)** — Build searchable hiring intelligence tables
- **[Zapier](https://apify.com/integrations/zapier)** — Trigger notifications, CRM updates, or Slack alerts when new jobs match your criteria
- **[Make](https://apify.com/integrations/make)** — Automate downstream workflows and data pipelines
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — Deliver fresh results to your own API endpoints

**Export formats:** JSON, CSV, Excel, XML — download directly from the Apify Console or via the [API](https://docs.apify.com/api/v2).

### FAQ

**How fresh is the data?**
Data is extracted live from Startup.jobs at the time of each run. Schedule [recurring runs](https://docs.apify.com/platform/schedules) to keep your dataset up to date — daily, weekly, or at any interval.

**Can I get full job descriptions?**
Yes. Enable `collectDetails` to fetch the full job description text and HTML from each detail page. This costs $1.50/1,000 jobs vs $1/1,000 for listings only.

**Why are some salary fields empty?**
Not all employers publish salary information on Startup.jobs. When salary data is not available, the `salary`, `salary_min`, `salary_max`, and `salary_currency` fields will be null.

**Can I filter by employment type or workplace type?**
The `keyword` field accepts any search term — you can use it to target specific employment types (e.g. "part-time data analyst"). The `location` filter set to "Remote" automatically filters for remote-only positions via the Algolia search API.

**How many jobs can I scrape per run?**
Up to 500 jobs per run using the `results_wanted` parameter. The scraper automatically paginates through as many pages as needed. For larger collections, schedule multiple runs with different keywords.

**Can I use a custom Startup.jobs URL?**
Yes. Paste any Startup.jobs listing URL into the `startUrl` field — it overrides the keyword and location filters. This is useful for scraping specific search result pages or filtered views.

**Does this scraper need proxies?**
No proxies are required for basic usage. The scraper uses a stealth browser to bypass Cloudflare protection and then queries the Algolia search API directly. On Apify, it runs without additional proxy configuration.

**Can I access the data via API?**
Yes. Use the [Apify API](https://docs.apify.com/api/v2) to start runs, retrieve results, and integrate Startup.jobs data into your own applications. See the Python and JavaScript examples above.

**Something not working? Have a feature request?**
Open an issue in the [Issues tab](https://console.apify.com/actors/parsebird~startup-jobs-scraper/issues) — we respond to all reports.

### Is it legal to scrape Startup.jobs?

This Actor extracts publicly available job listing data from [Startup.jobs](https://startup.jobs) — the same information any visitor can see in their browser. It does not bypass authentication, access private data, or violate CAPTCHA protections.

Web scraping of publicly available data is generally considered legal in the United States and European Union, as affirmed by the [US Ninth Circuit ruling in HiQ v. LinkedIn](https://docs.apify.com/academy/anti-scraping/is-web-scraping-legal). However, users are responsible for ensuring their use of extracted data complies with applicable laws, regulations, and the target website's Terms of Service.

For more context, see Apify's guide: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

### Other job scrapers on Apify

Looking for job data from other platforms? Check out these ParseBird scrapers:

- **[Hiring.cafe Jobs Scraper](https://apify.com/parsebird/hiring-cafe-scraper)** — Search across 20+ job boards with keyword, location, salary, and seniority filters
- **[Dice Jobs Scraper](https://apify.com/parsebird/dice-jobs-scraper)** — Extract tech job listings from Dice.com
- **[Wellfound Jobs Scraper](https://apify.com/parsebird/wellfound-jobs-scraper)** — Scrape startup jobs from Wellfound (formerly AngelList Talent)
- **[Xing Jobs Scraper](https://apify.com/parsebird/xing-jobs-scraper)** — Extract job listings from Xing, the leading DACH job platform
- **[Rozee.pk Jobs Scraper](https://apify.com/parsebird/rozeepk-jobs-scraper)** — Scrape jobs from Pakistan's largest job board
- **[Arbeitsagentur Scraper](https://apify.com/parsebird/arbeitsagentur-scraper)** — Extract job listings from Germany's Federal Employment Agency

# Actor input Schema

## `startUrl` (type: `string`):

Custom Startup.jobs listing URL. When provided, it overrides keyword and location filters.

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

Job title or skills to search for (e.g. 'software engineer', 'product manager', 'data scientist').

## `location` (type: `string`):

Location filter. Use 'Remote' for remote-first jobs, or enter a city or country name.

## `collectDetails` (type: `boolean`):

Fetch full job descriptions and application links from each job detail page. Costs $1.50/1,000 jobs with details vs $1/1,000 without.

## `results_wanted` (type: `integer`):

Maximum number of job listings to collect (1–500).

## Actor input object example

```json
{
  "keyword": "software engineer",
  "location": "Remote",
  "collectDetails": false,
  "results_wanted": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keyword": "software engineer",
    "location": "Remote",
    "collectDetails": false,
    "results_wanted": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/startup-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 = {
    "keyword": "software engineer",
    "location": "Remote",
    "collectDetails": False,
    "results_wanted": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/startup-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 '{
  "keyword": "software engineer",
  "location": "Remote",
  "collectDetails": false,
  "results_wanted": 20
}' |
apify call parsebird/startup-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Startup.jobs Scraper",
        "description": "Extract job listings from Startup.jobs — titles, companies, salaries, locations, descriptions, and application links. Filter by keyword and location. Export as JSON, CSV, Excel. Pay per result.",
        "version": "1.2",
        "x-build-id": "t1VyrMznxo3V20mXc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parsebird~startup-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parsebird-startup-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/parsebird~startup-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parsebird-startup-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/parsebird~startup-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parsebird-startup-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": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "Custom Startup.jobs listing URL. When provided, it overrides keyword and location filters."
                    },
                    "keyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Job title or skills to search for (e.g. 'software engineer', 'product manager', 'data scientist').",
                        "default": ""
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location filter. Use 'Remote' for remote-first jobs, or enter a city or country name.",
                        "default": "Remote"
                    },
                    "collectDetails": {
                        "title": "Collect Job Details",
                        "type": "boolean",
                        "description": "Fetch full job descriptions and application links from each job detail page. Costs $1.50/1,000 jobs with details vs $1/1,000 without.",
                        "default": false
                    },
                    "results_wanted": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of job listings to collect (1–500).",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```