# Glassdoor Scraper - Jobs, Companies & Salaries (`makework36/glassdoor-scraper`) Actor

Scrape Glassdoor job listings: title, company, location, salary parsed, employment type, description. 25+ structured fields per job via JSON-LD. HTTP-only, low cost.

- **URL**: https://apify.com/makework36/glassdoor-scraper.md
- **Developed by:** [deusex machine](https://apify.com/makework36) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Glassdoor Scraper API — Jobs, Companies, Salaries & Reviews Data

A high-performance **Glassdoor scraper** that extracts complete job listings from [Glassdoor.com](https://www.glassdoor.com), one of the most trusted job & employer review platforms with 80M+ reviews and millions of active job postings across the US, UK, Canada, India, Australia, Germany and France. Pull 25+ structured fields per job — title, company name, location parsed to city/state/country, salary range with currency and unit, full description, employment type, posting date, and education/experience requirements — without writing a single line of HTML scraping logic.

Built for recruiters tracking US, UK and EMEA labor supply, market analysts comparing pay across [LinkedIn Jobs](https://www.linkedin.com/jobs), [Indeed](https://www.indeed.com), and [BLS](https://www.bls.gov) data, salary benchmarking firms, founders monitoring competitor hiring patterns, and ML teams training resume-to-job matching pipelines against the [schema.org JobPosting](https://schema.org/JobPosting) schema. Output is clean JSON, ready for [Google BigQuery](https://cloud.google.com/bigquery), Snowflake, Postgres, or [Google Sheets](https://workspace.google.com/products/sheets/).

### ✨ Why use this scraper

This actor automates browsing **glassdoor.com** the way a real visitor does. It hits the public job search pages, walks through pagination, parses the embedded [schema.org JobPosting](https://schema.org/JobPosting) JSON-LD blocks served alongside each search result, and visits every individual job detail page to extract the full structured posting — title, company, salary, location, employment type, description, education and experience requirements.

The pricing logic is automatic: Glassdoor's JSON-LD baseSalary block becomes `salaryMin: 143913`, `salaryMax: 197200`, `salaryCurrency: "USD"`, `salaryUnit: "YEAR"`, plus a human-readable `salaryText: "$143,913 - $197,200 USD/year"`. Locations are split into city, state/region, country, postal code and street address, so downstream filtering by city or state works out of the box.

The scraper is HTTP-only — no headless browser, no captcha solver. Memory footprint is 512 MB, dramatically lower than the 4 GB needed by browser-based competitors. It runs on Apify's residential proxy network out of the box.

### 📤 Output fields

Every record contains these fields when present in Glassdoor's structured data:

#### Identity & links
- `title` — Position title
- `jobUrl` — Direct link to the Glassdoor listing
- `position` — Position in the search results ranking

#### Company
- `companyName` — Hiring company
- `companyUrl` — Company's external URL (sameAs from JSON-LD)
- `companyLogoUrl` — Logo image URL
- `industry` — Industry classification

#### Location
- `location` — Concatenated "City, State, Country" string
- `addressLocality` — City
- `addressRegion` — State or region
- `addressCountry` — Country name
- `postalCode` — Postal/ZIP code
- `streetAddress` — Street address when published
- `jobLocationType` — `"TELECOMMUTE"` when remote
- `applicantLocationRequirements` — Geographic eligibility

#### Salary
- `salaryText` — Human-readable formatted string
- `salaryMin` — Lower bound number
- `salaryMax` — Upper bound number
- `salaryValue` — Single value when no range is given
- `salaryCurrency` — `"USD"`, `"EUR"`, `"GBP"`, etc.
- `salaryUnit` — `"YEAR"`, `"HOUR"`, `"MONTH"`, `"WEEK"`

#### Description & requirements
- `jobDescription` — Full description text
- `jobDescriptionHtml` — Original HTML markup of the description
- `qualifications` — Required qualifications when separately published
- `responsibilities` — Day-to-day responsibilities
- `skills` — Skills list from JSON-LD when provided
- `educationRequirements` — Education level required
- `experienceRequirements` — Experience required

#### Timestamps & employment type
- `datePosted` — ISO 8601 posting date
- `postedDate` — Alias of datePosted
- `validThrough` — Listing expiration date
- `employmentType` — Array of types (`"FULL_TIME"`, `"PART_TIME"`, `"CONTRACTOR"`, `"INTERN"`)
- `directApply` — Boolean: can apply directly on Glassdoor?

### 🎯 Use cases

1. **Recruitment talent radar** — Track jobs matching your hiring niche, filter by `addressRegion` for US states, by `employmentType` for full-time only, by `salaryMin` for compensation bands.
2. **Salary benchmarking** — Aggregate `salaryMin`/`salaryMax` by job title + location to produce reliable pay bands. The `salaryUnit` field lets you cleanly separate hourly vs annual data.
3. **Hiring intelligence** — Track which companies are scaling specific functions. Combine `companyName` + `industry` for clean B2B segmentation.
4. **ML training corpora** — Pair `title`, full `jobDescription`, `educationRequirements`, and `experienceRequirements` to train resume-to-job matching models.
5. **Lead generation** — Identify companies actively hiring in your niche (e.g. all US companies hiring a "VP of Engineering"). Use `companyName` + `addressLocality` for geographic prospecting.
6. **Compensation transparency reports** — Detect employers consistently posting salary ranges vs those who don't, useful for pay equity research.

### 🚀 How to use

#### Mode 1 — Search by keywords (easiest)

```json
{
  "mode": "keywords",
  "keywords": ["python developer", "data engineer"],
  "country": "us",
  "maxJobs": 100,
  "fetchDetails": true
}
````

#### Mode 2 — Multi-country pipeline

```json
{
  "mode": "keywords",
  "keywords": ["software engineer"],
  "country": "uk",
  "maxJobs": 200,
  "fetchDetails": true
}
```

#### Mode 3 — Pre-built search URLs (advanced)

```json
{
  "mode": "urls",
  "searchUrls": [
    { "url": "https://www.glassdoor.com/Job/remote-python-developer-jobs-SRCH_IL.0,6_IS11047_KO7,23.htm" }
  ],
  "maxJobs": 50,
  "fetchDetails": true
}
```

### 📥 Input

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | enum | `"keywords"` | `"keywords"` or `"urls"` |
| `keywords` | array | `["python developer"]` | Job titles / keywords |
| `country` | enum | `"us"` | Regional Glassdoor domain |
| `searchUrls` | array | `[]` | Pre-built URLs (urls mode) |
| `maxJobs` | integer | `50` | Cap per keyword/URL |
| `fetchDetails` | boolean | `true` | Visit detail pages for full structured data |
| `proxyConfiguration` | object | RESIDENTIAL | Apify proxy (residential recommended) |

### 📋 Output example

```json
{
  "position": 1,
  "title": "Python Developer",
  "jobUrl": "https://www.glassdoor.com/job-listing/python-developer-social-security-administration-...",
  "companyName": "US Social Security Administration",
  "companyLogoUrl": "https://media.glassdoor.com/sql/...png",
  "companyUrl": "https://www.ssa.gov",
  "industry": "Government",
  "location": "Woodlawn, Maryland, United States",
  "addressLocality": "Woodlawn",
  "addressRegion": "Maryland",
  "addressCountry": "United States",
  "salaryText": "$143,913 - $197,200 USD/year",
  "salaryMin": 143913,
  "salaryMax": 197200,
  "salaryCurrency": "USD",
  "salaryUnit": "YEAR",
  "employmentType": ["FULL_TIME"],
  "datePosted": "2026-05-06T00:00:00",
  "validThrough": "2026-06-06T00:00:00",
  "jobDescription": "Summary IT Specialist (APPSW), Python Developer position(s) are being filled through the Office of Personnel Management...",
  "educationRequirements": "Bachelor's degree",
  "experienceRequirements": "5 years"
}
```

### 💻 Code examples

#### From the Apify API (curl)

```bash
curl -X POST "https://api.apify.com/v2/acts/makework36~glassdoor-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "keywords",
    "keywords": ["data engineer"],
    "country": "us",
    "maxJobs": 100,
    "fetchDetails": true
  }'
```

#### From Python (apify-client)

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("makework36/glassdoor-scraper").call(run_input={
    "mode": "keywords",
    "keywords": ["python developer", "data scientist"],
    "country": "us",
    "maxJobs": 200,
    "fetchDetails": True,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], job["companyName"], job.get("salaryText"))
```

#### From Node.js (apify-client)

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('makework36/glassdoor-scraper').call({
    mode: 'keywords',
    keywords: ['software engineer'],
    country: 'us',
    maxJobs: 100,
    fetchDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} jobs`);
```

#### Export to CSV

```bash
curl "https://api.apify.com/v2/acts/makework36~glassdoor-scraper/runs/last/dataset/items?format=csv&token=$APIFY_TOKEN" \
  -o glassdoor_jobs.csv
```

### ⚡ Performance

| Mode | Time per job | 100 jobs ETA |
|---|---:|---:|
| Search only (titles + URLs) | ~0.5 s | ~50 s |
| With `fetchDetails: true` | ~7–15 s | ~12–25 min |

Detailed mode visits each individual job page to extract the full JSON-LD JobPosting. This is necessary for salary, full description, employment type and address. Search-only mode is much faster but returns only title + URL.

### 📊 Comparison

| Feature | This actor | Browser-only with proxy | Headless + captcha solver |
|---|:---:|:---:|:---:|
| Output fields | 25+ structured | 15–20 | 18 |
| Salary parsed to Min/Max/Currency/Unit | ✅ | partial | partial |
| Location split (city/state/country) | ✅ | ❌ | ❌ |
| Pure HTTP (no browser) | ✅ | ❌ | ❌ |
| Memory footprint | 512 MB | 4 GB | 4 GB |
| Captcha solver required | ❌ | ❌ | ✅ |
| Pricing model | PAY\_PER\_EVENT tiered | flat | flat |

### 💵 Pricing

This actor uses **PAY\_PER\_EVENT** pricing with tiered volume discounts.

| Tier | Standard job (URL+title only) | Detailed job (full JSON-LD) |
|:-----|---:|---:|
| FREE | $1.50 / 1K | $7.50 / 1K |
| BRONZE | $1.10 / 1K | $5.50 / 1K |
| SILVER | $0.80 / 1K | $4.00 / 1K |
| GOLD | $0.55 / 1K | $2.80 / 1K |
| PLATINUM | $0.40 / 1K | $2.20 / 1K |
| DIAMOND | $0.28 / 1K | $1.80 / 1K |

Plus a one-time **$0.001 per actor run**. Detailed mode is the default because Glassdoor's value lives in the structured JobPosting data on each individual page.

### ❓ FAQ

**Why does the scraper need Residential proxies?**
Glassdoor blocks datacenter IPs aggressively. Residential proxies route traffic through real households, which Glassdoor accepts. Apify includes residential proxy access in most paid plans.

**Is scraping Glassdoor legal?**
This actor accesses publicly available job pages — no login, no paywall bypass, no PII extraction beyond what employers post publicly. Always check Glassdoor's terms of service and consult legal counsel for your jurisdiction.

**Can I scrape Glassdoor company reviews / salaries?**
No — this actor focuses on job listings. Glassdoor's reviews and aggregated salary reports require a different stack and have different terms-of-service implications.

**Does this support Glassdoor UK / Canada / Germany / France?**
Yes. Set `country` to `uk`, `ca`, `de`, `fr`, `in`, or `au` and the scraper hits the matching regional Glassdoor domain.

**How fresh is the data?**
The scraper fetches in real time at run start. Glassdoor updates listings continuously.

**Can I scrape Glassdoor without writing code?**
Yes — use the input form on this page, click Start, then download the dataset as CSV or Excel.

**Why are `qualifications` and `responsibilities` fields sometimes empty?**
Not all Glassdoor postings split these out as separate JSON-LD properties. When absent, the same information typically lives inside `jobDescription` as a paragraph.

**Does the scraper deduplicate jobs?**
Yes. Each `jobUrl` is tracked across pages within a run; duplicates are skipped.

**Is there a rate limit on my side?**
The actor uses jitter between pages and rotates proxy sessions automatically. For very large runs (>5,000 jobs), split across multiple Apify Tasks scheduled minutes apart.

### 📝 Changelog

- **0.1** (2026-05) — Initial release. Keywords + URLs modes. JSON-LD parsing for search and detail. 25+ fields. Residential proxy default.

### 🔗 Related actors

- [`makework36/indeed-scraper`](https://apify.com/makework36/indeed-scraper) — Indeed.com US jobs
- [`makework36/naukri-scraper`](https://apify.com/makework36/naukri-scraper) — Naukri.com India jobs
- [`makework36/trustpilot-reviews-scraper`](https://apify.com/makework36/trustpilot-reviews-scraper) — Trustpilot reviews
- [`makework36/google-maps-scraper-full`](https://apify.com/makework36/google-maps-scraper-full) — Google Maps places

# Actor input Schema

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

'keywords' searches Glassdoor by keyword. 'urls' takes pre-built search URLs.

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

Job titles or keywords to search (e.g. 'python developer', 'data scientist').

## `searchUrls` (type: `array`):

Pre-built Glassdoor search URLs.

## `country` (type: `string`):

Glassdoor regional domain to search on.

## `maxJobs` (type: `integer`):

Maximum jobs per keyword/URL. Glassdoor shows ~30 jobs per page.

## `fetchDetails` (type: `boolean`):

Visit each job detail page for full description + JSON-LD JobPosting (salary, employment type, address). Slower but ~20 extra fields.

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

Apify proxy. Residential recommended to avoid Glassdoor rate-limiting.

## Actor input object example

```json
{
  "mode": "keywords",
  "keywords": [
    "python developer"
  ],
  "searchUrls": [],
  "country": "us",
  "maxJobs": 10,
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("makework36/glassdoor-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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    } }

# Run the Actor and wait for it to finish
run = client.actor("makework36/glassdoor-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 '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call makework36/glassdoor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Glassdoor Scraper - Jobs, Companies & Salaries",
        "description": "Scrape Glassdoor job listings: title, company, location, salary parsed, employment type, description. 25+ structured fields per job via JSON-LD. HTTP-only, low cost.",
        "version": "0.1",
        "x-build-id": "wznKcPMqNRMCirOyE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/makework36~glassdoor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-makework36-glassdoor-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/makework36~glassdoor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-makework36-glassdoor-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/makework36~glassdoor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-makework36-glassdoor-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "keywords",
                            "urls"
                        ],
                        "type": "string",
                        "description": "'keywords' searches Glassdoor by keyword. 'urls' takes pre-built search URLs.",
                        "default": "keywords"
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Job titles or keywords to search (e.g. 'python developer', 'data scientist').",
                        "default": [
                            "python developer"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Pre-built Glassdoor search URLs.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "country": {
                        "title": "Glassdoor country",
                        "enum": [
                            "us",
                            "uk",
                            "ca",
                            "in",
                            "au",
                            "de",
                            "fr"
                        ],
                        "type": "string",
                        "description": "Glassdoor regional domain to search on.",
                        "default": "us"
                    },
                    "maxJobs": {
                        "title": "Max jobs",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum jobs per keyword/URL. Glassdoor shows ~30 jobs per page.",
                        "default": 10
                    },
                    "fetchDetails": {
                        "title": "Fetch detailed job info",
                        "type": "boolean",
                        "description": "Visit each job detail page for full description + JSON-LD JobPosting (salary, employment type, address). Slower but ~20 extra fields.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify proxy. Residential recommended to avoid Glassdoor rate-limiting.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
