# Indeed & ZipRecruiter Scraper — Jobs, Hiring Signals, Profiles (`openclawai/indeed-ziprecruiter-scraper`) Actor

Scrape Indeed and ZipRecruiter in one run: company hiring signals with live job totals, fresh job postings by company or keyword with exact timestamps and salaries, and company profile enrichment. CSV-ready output for recruiting outreach, lead scoring, and market research. X402, MPP, MCP

- **URL**: https://apify.com/openclawai/indeed-ziprecruiter-scraper.md
- **Developed by:** [Pika Choo](https://apify.com/openclawai) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 result (company or job record)s

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Indeed & ZipRecruiter Scraper — Hiring Signals, Job Search & Company Profiles

Scrape **Indeed** and **ZipRecruiter** in one run. Track which companies are
hiring, pull fresh job postings by company or keyword, and enrich company
profiles — built for **recruiting outreach, sales lead scoring, talent-market
research, and marketing automation** pipelines.

### Three scan modes in one actor

| Mode | You provide | You get |
|---|---|---|
| **Companies** (default) | A list of company names (optionally with websites) | Hiring signal per company (active-posting counts per board + ZipRecruiter live job total), full company profile, and the latest jobs — posted in the last N hours or the latest 10 |
| **Keywords** | Up to 10 search terms | Fresh job postings matching each keyword across both boards, with salary, location, remote flag and exact posting timestamps |
| **Profiles** | A list of company names | Company profiles only — industry, size, revenue, HQ, founding year, rating, live job count — fast and lightweight |

### Why this scraper

- ✅ **Two job boards, one dataset** — Indeed and ZipRecruiter results merged,
  deduplicated, and labeled per source
- ✅ **Real posting timestamps** — ZipRecruiter jobs carry exact hour-precise
  `posted_at` timestamps taken from the page itself; repost/refresh bumps are
  detected and reported separately (`reposted_at`), so a "fresh" job is
  genuinely fresh
- ✅ **True 24h / 48h recency filtering** — done by timestamp, more accurate
  than the boards' own date filters
- ✅ **Employer-verified matching** — jobs are matched to the target company by
  website domain plus normalized name, so common names ("Kelly", "Volt") don't
  pull in unrelated employers
- ✅ **Live job totals** — the company's real ZipRecruiter posting count, not a
  page-limited sample: a direct hiring-volume signal
- ✅ **Company profiles from both boards** — industry, employee count, revenue,
  description, logo, HQ, founding year, employee rating, socials, website
- ✅ **CSV-ready output** — every job also lands as a flat one-row-per-job
  record, so exports open clean in Excel / Google Sheets
- ✅ **Resilient by design** — automatic retries, browser crash recovery, IP
  rotation, and per-site timeouts; partial results are saved incrementally

### Output

One **company record** per target (mode: companies/profiles):

```json
{
  "record_type": "company",
  "company_query": "Paychex",
  "has_active_postings": true,
  "active_jobs_by_site": { "indeed": 17, "zip_recruiter": 21 },
  "active_jobs_total_by_site": { "zip_recruiter": 593 },
  "posted_last_48h_count": 17,
  "profile": {
    "company_industry": "Human Resources",
    "company_num_employees": "10,000+",
    "company_revenue": "$1B to $5B (USD)",
    "zr_total_jobs": 593,
    "zr_rating": 7.27,
    "zr_headquarters": "Rochester, NY, US",
    "zr_year_founded": "1971"
  },
  "latest_jobs": [ { "title": "…", "posted_at": "2026-07-07T06:55:00Z", "job_url": "…" } ]
}
````

Plus flat **job records** (all modes) with title, company, location, posting
date and exact timestamp, salary range, job type, remote flag, and direct
application URL — and per-keyword **summary records** in keyword mode.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `scanMode` | `companies` | `keywords` | `profiles` | `companies` | See modes above. |
| `companies` | array | — | Company names; add the website for precise matching: `"Kelly Services \| kellyservices.com"`. |
| `keywords` | array | — | Search terms (keyword mode, max 10). Indeed operators supported: `"exact phrase"`, `-exclude`, `(a OR b)`. |
| `location` | string | `United States` | Search location (ZipRecruiter covers US & Canada). |
| `recencyMode` | `last48h` | `latest10` | `last48h` | Jobs in the recency window, or the 10 most recent regardless of age. |
| `hoursOld` | integer | `48` | Recency window in hours. |
| `maxJobsPerCompany` | integer | `50` | Per company/keyword per site cap. |
| `sites` | array | both | `indeed`, `zip_recruiter`. |
| `includeDescription` | boolean | `false` | Attach full job descriptions. |
| `emitJobRecords` | boolean | `true` | Also push each job as its own flat row for clean CSV export. |
| `proxyConfiguration` | object | Residential | Residential proxy strongly recommended. |

### Data freshness notes

- ZipRecruiter rows are filtered by their exact posting timestamp
  (hour-precise). Indeed reports dates, so its rows are day-precise.
- ZipRecruiter ingests new postings in daily batches, so its freshest jobs are
  typically 12–48 hours old — for guaranteed two-board coverage use a 48-hour
  window; a 24-hour window is primarily driven by Indeed.
- Job counts per run are bounded by `maxJobsPerCompany`;
  `active_jobs_total_by_site.zip_recruiter` is the company's real total from
  its ZipRecruiter page.

### Output reference

**Company record** (`record_type: "company"`, modes: companies / profiles)

| Field | What it tells you |
|---|---|
| `has_active_postings` | The core hiring signal — is this company hiring right now? |
| `active_jobs_by_site` | Employer-verified posting counts per board this run |
| `active_jobs_total_by_site.zip_recruiter` | The company's **real total** open ZipRecruiter postings — hiring volume at a glance |
| `posted_last_48h_count` | How many postings fall inside your recency window |
| `profile.*` | Industry, employee count, revenue, description, logo, HQ, founding year, employee rating, website, socials |
| `latest_jobs` | The returned jobs, nested (also emitted as flat rows) |

**Job record** (`record_type: "job"`, all modes)

| Field | What it tells you |
|---|---|
| `title`, `company`, `location` | The posting basics |
| `date_posted` / `posted_at` | Original posting date, plus the exact UTC timestamp where the board exposes one |
| `reposted_at` | Present when the employer bumped/refreshed an older ad — a re-engagement signal, never disguised as a new posting |
| `salary_min/max/interval/currency` | Structured pay data (direct or parsed) |
| `job_url` | Direct employer application link when available, board link otherwise |
| `site` | Which board the row came from |

**Keyword summary** (`record_type: "keyword"`, keyword mode): totals per term
and per board plus how many matches fell inside the window.

### What teams build with it

- **Recruiting & staffing outreach** — run your target-account list daily;
  when `posted_last_48h_count` goes positive, that account enters your
  campaign with the actual job titles and salaries in the first line
- **Candidate-matching pipelines** — feed the flat job rows (title, salary,
  location, remote flag, timestamps) straight into an AI matching engine and
  email the shortlist while the posting is hours old
- **Sales lead scoring** — hiring velocity is one of the strongest buying
  signals; score accounts by live job totals and fresh-posting counts
- **Talent-market & compensation research** — keyword mode across regions
  gives posting volume and salary ranges per role, per board
- **CRM enrichment** — profiles mode fills industry, size, revenue, HQ,
  founding year and rating for thousands of records without touching the
  job feed

### Scheduling & integration

Runs on Apify like any actor: trigger on a schedule (e.g. every morning
after job boards refresh), call it via the REST API from your own stack,
or wire webhooks/integrations (Make, Zapier, Google Sheets) to push each
run's dataset into your pipeline. Results export as JSON, CSV, or Excel
directly from the dataset — the flat job rows are designed to open clean
in a spreadsheet with zero rework.

### FAQ

**How accurate is the company matching?** Jobs are matched by the employer's
website domain first (when you supply `Name | website`), with a normalized-name
fallback. Generic names ("Kelly", "Volt") won't pull in unrelated employers.

**Why do the two boards show different freshness?** Indeed timestamps postings
same-day; ZipRecruiter ingests in daily batches, so its newest postings are
typically 12–48h old. A 48-hour window gives full two-board coverage.

**What's a repost and why does it matter?** Boards let employers "bump" old
ads to the top. This actor reports the original posting date (what the job
page itself shows) and surfaces the bump separately as `reposted_at` — so your
"posted in the last 24 hours" list contains only genuinely new jobs.

**Can I search jobs without a company list?** Yes — `scanMode: "keywords"`
searches both boards by term, with the same recency filtering and flat output.

**What locations are covered?** Indeed supports country selection via
`countryIndeed`; ZipRecruiter covers the US and Canada.

# Actor input Schema

## `scanMode` (type: `string`):

companies = hiring signal + profile + jobs per target company. keywords = search jobs by keyword across both boards (no company targeting). profiles = company profiles only (fast, no job feed).

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

Search terms for scanMode=keywords, one per entry (max 10). Supports Indeed operators like quotes and -exclusions, e.g. '"registered nurse" -travel'.

## `companies` (type: `array`):

Companies to look up. Each entry can be just a name ("Insperity"), or a name with its website for precise matching ("Kelly | kellyservices.com"). Via the API you may also pass {name, website} objects. The website disambiguates common names (e.g. Kelly Services vs. unrelated 'Kelly' firms).

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

Search location. Recommended — ZipRecruiter returns poor/empty results without one (US & Canada only).

## `recencyMode` (type: `string`):

last48h = only postings within the recency window (see 'Hours old'). latest10 = the 10 most recent postings regardless of age.

## `hoursOld` (type: `integer`):

Used when 'Which jobs to return' = last48h. Enforced at day granularity (ZipRecruiter only reports dates, not times), so 48 = a 2-day window.

## `maxJobsPerCompany` (type: `integer`):

Ceiling on postings fetched per company per site. Also caps the 'active jobs' count (neither board exposes a true total).

## `sites` (type: `array`):

Only Indeed and ZipRecruiter are supported by this actor.

## `includeDescription` (type: `boolean`):

Attach the full description to each returned job. Adds latency on Indeed.

## `emitJobRecords` (type: `boolean`):

Besides the per-company record (nested latest\_jobs), push each returned job as its own flat dataset row (record\_type='job') so CSV export is clean. Filter the record\_type column to separate companies from jobs.

## `countryIndeed` (type: `string`):

Country domain for Indeed (e.g. usa, uk, canada).

## `matchThreshold` (type: `number`):

Fuzzy-match strictness (0-1) for keeping a posting whose employer name resembles the target. Higher = stricter.

## `descriptionFormat` (type: `string`):

Format for job descriptions when included.

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

Proxy for scraping. Residential is strongly recommended — ZipRecruiter 429-blocks datacenter IPs.

## Actor input object example

```json
{
  "scanMode": "companies",
  "keywords": [
    "registered nurse",
    "forklift operator"
  ],
  "companies": [
    "Insperity | insperity.com",
    "Kelly Services | kellyservices.com"
  ],
  "location": "United States",
  "recencyMode": "last48h",
  "hoursOld": 48,
  "maxJobsPerCompany": 50,
  "sites": [
    "indeed",
    "zip_recruiter"
  ],
  "includeDescription": false,
  "emitJobRecords": true,
  "countryIndeed": "usa",
  "matchThreshold": 0.82,
  "descriptionFormat": "markdown",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `jobs` (type: `string`):

No description

## `companies` (type: `string`):

No description

## `results` (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 = {
    "companies": [
        "Insperity | insperity.com",
        "Paychex | paychex.com"
    ],
    "location": "United States",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("openclawai/indeed-ziprecruiter-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 = {
    "companies": [
        "Insperity | insperity.com",
        "Paychex | paychex.com",
    ],
    "location": "United States",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("openclawai/indeed-ziprecruiter-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 '{
  "companies": [
    "Insperity | insperity.com",
    "Paychex | paychex.com"
  ],
  "location": "United States",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call openclawai/indeed-ziprecruiter-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed & ZipRecruiter Scraper — Jobs, Hiring Signals, Profiles",
        "description": "Scrape Indeed and ZipRecruiter in one run: company hiring signals with live job totals, fresh job postings by company or keyword with exact timestamps and salaries, and company profile enrichment. CSV-ready output for recruiting outreach, lead scoring, and market research. X402, MPP, MCP",
        "version": "0.1",
        "x-build-id": "RocBZ4FPScHXPjzZm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/openclawai~indeed-ziprecruiter-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-openclawai-indeed-ziprecruiter-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/openclawai~indeed-ziprecruiter-scraper/runs": {
            "post": {
                "operationId": "runs-sync-openclawai-indeed-ziprecruiter-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/openclawai~indeed-ziprecruiter-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-openclawai-indeed-ziprecruiter-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": {
                    "scanMode": {
                        "title": "Scan mode",
                        "enum": [
                            "companies",
                            "keywords",
                            "profiles"
                        ],
                        "type": "string",
                        "description": "companies = hiring signal + profile + jobs per target company. keywords = search jobs by keyword across both boards (no company targeting). profiles = company profiles only (fast, no job feed).",
                        "default": "companies"
                    },
                    "keywords": {
                        "title": "Keywords (keyword mode)",
                        "type": "array",
                        "description": "Search terms for scanMode=keywords, one per entry (max 10). Supports Indeed operators like quotes and -exclusions, e.g. '\"registered nurse\" -travel'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companies": {
                        "title": "Target companies",
                        "type": "array",
                        "description": "Companies to look up. Each entry can be just a name (\"Insperity\"), or a name with its website for precise matching (\"Kelly | kellyservices.com\"). Via the API you may also pass {name, website} objects. The website disambiguates common names (e.g. Kelly Services vs. unrelated 'Kelly' firms).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Search location. Recommended — ZipRecruiter returns poor/empty results without one (US & Canada only).",
                        "default": "United States"
                    },
                    "recencyMode": {
                        "title": "Which jobs to return",
                        "enum": [
                            "last48h",
                            "latest10"
                        ],
                        "type": "string",
                        "description": "last48h = only postings within the recency window (see 'Hours old'). latest10 = the 10 most recent postings regardless of age.",
                        "default": "last48h"
                    },
                    "hoursOld": {
                        "title": "Hours old (recency window)",
                        "minimum": 1,
                        "maximum": 720,
                        "type": "integer",
                        "description": "Used when 'Which jobs to return' = last48h. Enforced at day granularity (ZipRecruiter only reports dates, not times), so 48 = a 2-day window.",
                        "default": 48
                    },
                    "maxJobsPerCompany": {
                        "title": "Max jobs per company",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Ceiling on postings fetched per company per site. Also caps the 'active jobs' count (neither board exposes a true total).",
                        "default": 50
                    },
                    "sites": {
                        "title": "Job boards",
                        "type": "array",
                        "description": "Only Indeed and ZipRecruiter are supported by this actor.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "indeed",
                                "zip_recruiter"
                            ],
                            "enumTitles": [
                                "Indeed",
                                "ZipRecruiter"
                            ]
                        },
                        "default": [
                            "indeed",
                            "zip_recruiter"
                        ]
                    },
                    "includeDescription": {
                        "title": "Include full job description",
                        "type": "boolean",
                        "description": "Attach the full description to each returned job. Adds latency on Indeed.",
                        "default": false
                    },
                    "emitJobRecords": {
                        "title": "Also emit one flat row per job",
                        "type": "boolean",
                        "description": "Besides the per-company record (nested latest_jobs), push each returned job as its own flat dataset row (record_type='job') so CSV export is clean. Filter the record_type column to separate companies from jobs.",
                        "default": true
                    },
                    "countryIndeed": {
                        "title": "Indeed country",
                        "type": "string",
                        "description": "Country domain for Indeed (e.g. usa, uk, canada).",
                        "default": "usa"
                    },
                    "matchThreshold": {
                        "title": "Company match threshold",
                        "minimum": 0.5,
                        "maximum": 1,
                        "type": "number",
                        "description": "Fuzzy-match strictness (0-1) for keeping a posting whose employer name resembles the target. Higher = stricter.",
                        "default": 0.82
                    },
                    "descriptionFormat": {
                        "title": "Description format",
                        "enum": [
                            "markdown",
                            "html"
                        ],
                        "type": "string",
                        "description": "Format for job descriptions when included.",
                        "default": "markdown"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy for scraping. Residential is strongly recommended — ZipRecruiter 429-blocks datacenter IPs.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
