# Hirist.tech IT Jobs Scraper (`logiover/hirist-tech-scraper`) Actor

Hirist.tech IT jobs scraper and unofficial API alternative. Export tech job listings, salary, skills and recruiter data to CSV/JSON without login.

- **URL**: https://apify.com/logiover/hirist-tech-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 69 total users, 27 monthly users, 98.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

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

## Hirist.tech IT Jobs Scraper

Extract structured IT job listings from **[Hirist.tech](https://www.hirist.tech)** — India's #1 niche tech job portal with 4M+ registered professionals and 50K+ active listings. Salary ranges, tech skills, experience levels, recruiter info and full job descriptions — all in one place.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue)](https://apify.com)
[![Built with Crawlee](https://img.shields.io/badge/Built%20with-Crawlee-orange)](https://crawlee.dev)
[![Playwright](https://img.shields.io/badge/Engine-Playwright-green)]()

---

### Why Hirist.tech

Hirist.tech is India's most respected platform for IT and tech hiring. Unlike generic job boards, every listing here is tech-focused — with structured salary data in LPA, tech stack tags, and seniority levels. No existing Apify actor scrapes it properly.

**What makes this actor different:**
- **Salary data** — Every listing shows salary in LPA (Lakhs Per Annum). Parsed into `salaryMin` and `salaryMax` numbers
- **Tech stack as structured data** — Skills extracted as an array, not buried in text
- **Recruiter info** — Name and contact details when available
- **API interception** — The actor captures Hirist's own JSON API responses during page load, delivering clean pre-structured data without fragile DOM parsing
- **Full pagination** — Scrapes all pages, not just the first

---

### How It Works

Hirist.tech is a React Single Page Application. The actor uses Playwright to load each page and intercepts the XHR/fetch API calls that Hirist fires to load job data. This gives pre-structured JSON directly — no DOM parsing required in most cases. A DOM fallback handles edge cases.

**Flow:**
1. Build search URLs from keyword × city combinations
2. Load each search page with Playwright
3. Intercept Hirist's JSON API response → parse job cards
4. Optionally open each detail page for full description, exact salary and recruiter info
5. Paginate until `maxPages` or `maxJobs` reached

---

### Supported Tech Categories

Hirist.tech covers the full India IT job spectrum. Any keyword that appears in the URL pattern `/k/{keyword}-jobs` works:

| Category | Keywords |
|---|---|
| Backend | `java`, `python`, `node-js`, `golang`, `ruby`, `php` |
| Frontend | `react`, `angular`, `vue-js`, `javascript`, `typescript` |
| Mobile | `android`, `ios`, `react-native`, `flutter` |
| Data & AI | `data-science`, `machine-learning`, `deep-learning`, `data-engineering`, `nlp` |
| DevOps & Cloud | `devops`, `aws`, `azure`, `gcp`, `kubernetes`, `docker` |
| Database | `sql`, `mongodb`, `postgresql`, `elasticsearch`, `redis` |
| QA | `selenium`, `cypress`, `appium`, `performance-testing` |
| Security | `cybersecurity`, `penetration-testing`, `soc` |
| Architecture | `solution-architect`, `microservices`, `system-design` |
| All jobs | Leave `keywords` empty |

---

### Input

```json
{
  "keywords": ["python", "data-science", "devops"],
  "cities": ["bangalore", "hyderabad", "pune"],
  "experience": "2-5",
  "maxJobs": 300,
  "maxPages": 10,
  "scrapeDetails": true,
  "requestDelay": 1000,
  "maxConcurrency": 2
}
````

#### Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `keywords` | array | `[]` | Tech keywords to search. Empty = all jobs |
| `cities` | array | `[]` | City filters. Empty = all India |
| `experience` | string | `""` | Experience filter: `0-2`, `2-5`, `5-10`, `10+` or empty |
| `maxJobs` | integer | `100` | Max total jobs to scrape (0 = unlimited) |
| `maxPages` | integer | `10` | Max pages per keyword+city (0 = unlimited) |
| `scrapeDetails` | boolean | `true` | Open detail pages for full description + recruiter |
| `requestDelay` | integer (ms) | `1000` | Delay between page navigations |
| `maxConcurrency` | integer | `2` | Parallel browser tabs |

***

### Output

Each job is saved as one JSON record. Example:

```json
{
  "jobId": "1596353",
  "url": "https://www.hirist.tech/j/senior-python-engineer-at-razorpay-1596353",
  "title": "Senior Python Engineer",
  "company": "Razorpay",
  "companyType": "Product",
  "location": "Bangalore",
  "isRemote": false,
  "salaryMin": 25,
  "salaryMax": 40,
  "salaryRaw": "25 - 40 LPA",
  "experienceMin": 4,
  "experienceMax": 8,
  "experienceRaw": "4 - 8 Yrs",
  "skills": ["Python", "Django", "FastAPI", "PostgreSQL", "Redis", "AWS", "Microservices"],
  "description": "We are looking for a Senior Python Engineer to join our Payments Infrastructure team...",
  "recruiterName": "Priya Sharma",
  "postedAt": "2 days ago",
  "keyword": "python",
  "scrapedAt": "2026-04-15T10:00:00.000Z"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `jobId` | string | Unique Hirist job ID |
| `url` | string | Job detail page URL |
| `title` | string | Job title |
| `company` | string | Hiring company name |
| `companyType` | string | Product / Service / Startup / MNC |
| `location` | string | City or cities |
| `isRemote` | boolean | Remote/WFH flag |
| `salaryMin` | number | Minimum salary in LPA |
| `salaryMax` | number | Maximum salary in LPA |
| `salaryRaw` | string | Salary as displayed (`"25 - 40 LPA"`) |
| `experienceMin` | number | Min years of experience |
| `experienceMax` | number | Max years of experience |
| `experienceRaw` | string | Experience as displayed (`"4 - 8 Yrs"`) |
| `skills` | array | Required tech skills |
| `description` | string | Full job description |
| `recruiterName` | string | HR/recruiter contact name |
| `postedAt` | string | Post date/time |
| `keyword` | string | Keyword used to find this job |
| `scrapedAt` | string | Scrape timestamp (ISO 8601) |

#### Download Formats

JSON, JSONL, CSV, XLSX, XML — all available from Apify Console Dataset tab.

***

### Use Cases

- **Salary benchmarking** — `salaryMin`/`salaryMax` in LPA for every role. Compare Python vs Java vs DevOps pay across Indian cities
- **Tech stack demand analysis** — Which skills appear most across 50K+ listings? `skills` array enables aggregation
- **Recruiter outreach lists** — `recruiterName` for direct HR contacts
- **Job market monitoring** — Schedule daily runs to track new listings for specific tech stacks in target cities
- **Startup vs MNC intelligence** — `companyType` field lets you filter product companies from service firms
- **AI / LLM grounding** — `description` + `skills` + `salaryRaw` as structured context for job-matching agents, resume gap analysis or market research

***

### Automation & Integration

#### n8n / Make / Zapier

Schedule runs and route results to Google Sheets, Airtable, Slack alerts or CRM. Example: run daily for `machine-learning` in Bangalore, push new listings to a Slack channel.

#### Apify API

```bash
## Start a run
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["python", "data-science"],
    "cities": ["bangalore"],
    "maxJobs": 500,
    "scrapeDetails": true
  }'

## Get results
curl "https://api.apify.com/v2/datasets/YOUR_DATASET_ID/items?token=YOUR_TOKEN&format=json"
```

#### AI Pipelines

All fields are typed and consistently named. Integrate directly with LangChain, LlamaIndex or OpenAI function-calling for:

- Resume-to-job matching
- Salary prediction models
- India IT market trend analysis

***

### Technical Notes

- Hirist.tech is a React SPA — standard HTTP crawlers return empty pages
- This actor uses **Playwright** to fully render the React app
- **API interception** captures Hirist's own JSON API during page load — faster and more reliable than DOM parsing
- **DOM fallback** activates if API interception misses data
- Salary is in **LPA (Lakhs Per Annum)** — multiply by 100,000 for INR annual value
- Pagination uses `?page=N` query parameter or Next button click

***

### Legal & Ethical Use

Users are responsible for compliance with [Hirist.tech Terms of Service](https://www.hirist.tech/terms) and applicable Indian data protection regulations. Use reasonable delays and do not republish individual recruiter personal data.

***

### FAQ

#### Is this a Hirist.tech API alternative?

Yes. Hirist.tech has no public jobs API, so this actor works as an unofficial Hirist API alternative — it loads the React app with Playwright and intercepts Hirist's own JSON responses to deliver clean structured job data.

#### Can I scrape Hirist.tech without an API or login?

Yes. The actor scrapes Hirist.tech without any API key and without login. You just supply keywords, cities and an experience filter, and it returns structured listings.

#### How do I export Hirist.tech jobs to CSV or JSON?

Every run writes a dataset you can download as JSON, JSONL, CSV, XLSX or XML from the Apify Console Dataset tab, making it a simple Hirist.tech data export and CSV/JSON tool.

#### Does it extract salary and tech skills data?

Yes. This Hirist.tech IT jobs scraper parses salary into `salaryMin`/`salaryMax` in LPA and returns the required tech stack as a structured `skills` array.

### Changelog

#### 2026-06-15

- Reliability pass: re-verified end-to-end on live data with real-world inputs. Routine maintenance build.

#### 2026-06-07

- Docs: added coverage for Hirist API alternative, scraping without login, and CSV/JSON data export use cases.

#### 2026-06-05

- 🛡️ Reliability fix: results are no longer dropped by strict output validation — runs now complete cleanly even at high volume (thousands of results).
- ⚡ Stability & performance hardening; fresh rebuild.

| Version | Date | Notes |
|---|---|---|
| 1.0.0 | 2025-04-15 | Initial release — API intercept + DOM fallback, keyword/city/experience filters, full pagination |

### 📝 Changelog

#### 2026-06-04

- Verified live & refreshed build — reliability/maintenance pass.

# Actor input Schema

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

One or more job search keywords. Each keyword generates a separate search. Examples: 'python', 'react', 'java', 'data-science', 'devops', 'machine-learning', 'node-js', 'aws', 'android', 'ios'. Maps to hirist.tech URL: /k/{keyword}-jobs

## `cities` (type: `array`):

Filter by city. Maps to hirist.tech city filter. Examples: 'bangalore', 'delhi', 'mumbai', 'hyderabad', 'pune', 'chennai', 'noida', 'gurgaon'. Leave empty for all India.

## `experience` (type: `string`):

Filter by years of experience. Leave empty for all levels.

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

Maximum total jobs to scrape across all keywords and cities. Set to 0 for unlimited.

## `maxPages` (type: `integer`):

Maximum pages to paginate per keyword+city combination. Hirist shows ~15 jobs per page. Set to 0 for unlimited.

## `scrapeDetails` (type: `boolean`):

If enabled, opens each job's detail page for: full description, required skills, recruiter name, company details, exact salary range. Slower but much richer data.

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

Proxy settings. Hirist.tech is a React SPA with minimal bot protection. Residential proxies recommended for high-volume runs.

## `requestDelay` (type: `integer`):

Delay between page navigations in milliseconds.

## `maxConcurrency` (type: `integer`):

Parallel browser tabs for detail page scraping. Keep at 2–3 to avoid rate limiting.

## Actor input object example

```json
{
  "keywords": [
    "python"
  ],
  "cities": [
    "bangalore"
  ],
  "experience": "",
  "maxJobs": 25,
  "maxPages": 2,
  "scrapeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "requestDelay": 1000,
  "maxConcurrency": 2
}
```

# Actor output Schema

## `jobId` (type: `string`):

Unique Hirist job ID

## `url` (type: `string`):

Full job detail page URL

## `title` (type: `string`):

Job title

## `company` (type: `string`):

Hiring company name

## `companyType` (type: `string`):

Startup / MNC / Product / Service

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

Job location city/cities

## `isRemote` (type: `string`):

true if remote/WFH position

## `salaryMin` (type: `string`):

Minimum salary in LPA (Lakhs Per Annum)

## `salaryMax` (type: `string`):

Maximum salary in LPA (Lakhs Per Annum)

## `salaryRaw` (type: `string`):

Salary as displayed on listing

## `experienceMin` (type: `string`):

Minimum years of experience required

## `experienceMax` (type: `string`):

Maximum years of experience

## `experienceRaw` (type: `string`):

Experience requirement as displayed

## `skills` (type: `string`):

Required tech skills / stack

## `description` (type: `string`):

Full job description

## `recruiterName` (type: `string`):

Recruiter or HR contact name

## `postedAt` (type: `string`):

Job posting date/time

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

Keyword used to find this job

## `scrapedAt` (type: `string`):

ISO timestamp when this record was scraped

# 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 = {
    "keywords": [
        "python"
    ],
    "cities": [
        "bangalore"
    ],
    "maxJobs": 25,
    "maxPages": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/hirist-tech-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 = {
    "keywords": ["python"],
    "cities": ["bangalore"],
    "maxJobs": 25,
    "maxPages": 2,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/hirist-tech-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 '{
  "keywords": [
    "python"
  ],
  "cities": [
    "bangalore"
  ],
  "maxJobs": 25,
  "maxPages": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call logiover/hirist-tech-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hirist.tech IT Jobs Scraper",
        "description": "Hirist.tech IT jobs scraper and unofficial API alternative. Export tech job listings, salary, skills and recruiter data to CSV/JSON without login.",
        "version": "0.0",
        "x-build-id": "MPqgTAbXMiIJ9avj4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~hirist-tech-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-hirist-tech-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/logiover~hirist-tech-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-hirist-tech-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/logiover~hirist-tech-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-hirist-tech-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords / Tech Stack",
                        "type": "array",
                        "description": "One or more job search keywords. Each keyword generates a separate search. Examples: 'python', 'react', 'java', 'data-science', 'devops', 'machine-learning', 'node-js', 'aws', 'android', 'ios'. Maps to hirist.tech URL: /k/{keyword}-jobs",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities (optional)",
                        "type": "array",
                        "description": "Filter by city. Maps to hirist.tech city filter. Examples: 'bangalore', 'delhi', 'mumbai', 'hyderabad', 'pune', 'chennai', 'noida', 'gurgaon'. Leave empty for all India.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "experience": {
                        "title": "Experience Filter (optional)",
                        "enum": [
                            "",
                            "0-2",
                            "2-5",
                            "5-10",
                            "10+"
                        ],
                        "type": "string",
                        "description": "Filter by years of experience. Leave empty for all levels.",
                        "default": ""
                    },
                    "maxJobs": {
                        "title": "Max Jobs",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total jobs to scrape across all keywords and cities. Set to 0 for unlimited.",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Max Pages per Search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum pages to paginate per keyword+city combination. Hirist shows ~15 jobs per page. Set to 0 for unlimited.",
                        "default": 3
                    },
                    "scrapeDetails": {
                        "title": "Scrape Detail Pages",
                        "type": "boolean",
                        "description": "If enabled, opens each job's detail page for: full description, required skills, recruiter name, company details, exact salary range. Slower but much richer data.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Hirist.tech is a React SPA with minimal bot protection. Residential proxies recommended for high-volume runs."
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between page navigations in milliseconds.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Parallel browser tabs for detail page scraping. Keep at 2–3 to avoid rate limiting.",
                        "default": 2
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
