# WorkIndia Jobs Scraper (`automation-lab/workindia-jobs-scraper`) Actor

Extract public WorkIndia jobs by city, category, or URL with salary, company, locality, experience, qualification, and job links.

- **URL**: https://apify.com/automation-lab/workindia-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 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

## WorkIndia Jobs Scraper

Extract public WorkIndia job listings by city, category, listing URL, or job detail URL. Get salary, company, locality, category, experience, qualification, posted text, and optional detail-page enrichment in a clean dataset.

### What does WorkIndia Jobs Scraper do?

WorkIndia Jobs Scraper turns public pages on `workindia.in` into structured job-posting data.

Use it to monitor frontline hiring demand across Indian cities, compare local salary ranges, collect public job URLs for recruiting workflows, and track category-level job supply.

The actor is HTTP-first and reads the server-rendered WorkIndia pages that are visible without login.

It does not scrape private candidate data, resumes, hidden phone numbers, or authenticated employer dashboards.

### Who is it for?

Recruitment agencies can monitor active blue-collar and frontline job demand by city and role.

Staffing marketplaces can build market intelligence datasets for delivery, telecalling, retail, back-office, driver, and field-sales jobs.

HR analytics teams can compare salaries and hiring volume across localities.

Developers can plug structured WorkIndia job data into lead-routing, alerts, dashboards, or enrichment pipelines.

Researchers can observe public employment trends without manually browsing dozens of city/category pages.

### Why use this actor?

- ✅ Extracts public WorkIndia job cards into a typed dataset
- ✅ Supports city slugs and category slugs
- ✅ Accepts direct WorkIndia listing URLs and job detail URLs
- ✅ Optional detail-page enrichment for richer records
- ✅ No browser needed for the default workflow
- ✅ Includes source URL and scrape timestamp for auditability

### Typical use cases

- Track delivery hiring in Bengaluru, Mumbai, Delhi, Pune, and Hyderabad
- Compare monthly salary ranges by city and role
- Build a recruiter lead list from public job postings
- Monitor new postings in localities relevant to your business
- Enrich internal labor-market dashboards with WorkIndia supply data
- Create recurring alerts for high-volume categories

### Data fields

| Field | Description |
| --- | --- |
| `jobTitle` | Public WorkIndia job title |
| `jobUrl` | Canonical WorkIndia job detail URL |
| `companyName` | Company name when visible |
| `city` | City parsed from location or detail data |
| `locality` | Locality/neighborhood when visible |
| `location` | Full location text from WorkIndia |
| `category` | Job category such as Delivery or Telecaller |
| `salary` | Public salary range text |
| `minSalary` | Numeric minimum salary from detail data when available |
| `maxSalary` | Numeric maximum salary from detail data when available |
| `experience` | Experience requirement |
| `shiftOrTimings` | Job timings from detail pages |
| `qualification` | Education/gender requirement text when visible |
| `englishRequirement` | English requirement shown by WorkIndia |
| `openings` | Openings count from detail route data |
| `postedText` | Listing posted text |
| `postedAt` | Detail-page created timestamp when available |
| `description` | Job description from detail page |
| `jobAddress` | Job address from detail page |
| `interviewTimings` | Interview timing text |
| `views` | Listing badge text when visible |
| `tags` | Listing badges such as New or views |
| `sourceUrl` | Listing/detail URL that produced the record |
| `scrapedAt` | ISO timestamp of extraction |

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

This actor uses pay-per-event pricing.

There is a small start charge for each run and a per-job charge for each dataset item produced.

The default input is intentionally small so you can test cheaply before running broader city/category monitoring.

Current formula-derived BRONZE price is $0.005 per run start plus $0.000029093 per job item, with lower per-item prices on higher Apify tiers.

### Input options

#### Start URLs

Paste one or more WorkIndia listing URLs or job detail URLs.

Examples:

```json
[
  { "url": "https://www.workindia.in/jobs-in-bengaluru/" },
  { "url": "https://www.workindia.in/delivery-jobs-in-mumbai/" }
]
````

#### City slugs

Use WorkIndia city slugs such as:

- `bengaluru`
- `mumbai`
- `delhi`
- `pune`
- `hyderabad`
- `chennai`

The actor creates URLs like `https://www.workindia.in/jobs-in-bengaluru/`.

#### Category slugs

Use category slugs such as:

- `delivery`
- `telecalling`
- `accountant`
- `field-sales`
- `driver`
- `back-office`
- `retail`

When combined with city slugs, the actor creates URLs like `https://www.workindia.in/delivery-jobs-in-bengaluru/`.

#### Maximum jobs

`maxItems` is a global cap across all input URLs.

Use a small value for tests and a larger value for production monitoring.

#### Detail enrichment

Set `includeDetails` to `true` when you need description, openings, timings, address, salary bounds, and posted timestamp.

Detail enrichment makes one extra HTTP request per job.

### Example input: city monitoring

```json
{
  "citySlugs": ["bengaluru", "mumbai", "delhi"],
  "maxItems": 60,
  "includeDetails": false
}
```

### Example input: category monitoring

```json
{
  "citySlugs": ["bengaluru", "mumbai"],
  "categorySlugs": ["delivery", "telecalling", "driver"],
  "maxItems": 100,
  "includeDetails": true,
  "requestDelayMs": 250
}
```

### Example input: exact URLs

```json
{
  "startUrls": [
    { "url": "https://www.workindia.in/jobs-in-bengaluru/" },
    { "url": "https://www.workindia.in/delivery-jobs-in-bengaluru/" }
  ],
  "maxItems": 40,
  "includeDetails": false
}
```

### Example output

```json
{
  "jobTitle": "Delivery Executive / Rider",
  "jobUrl": "https://www.workindia.in/jobs/delivery_executive__rider-kogilu-bengaluru-10508257/",
  "companyName": "MANNEKERG SOLUTIONS PRIVATE LIMITED",
  "city": "Bengaluru",
  "locality": "Kogilu",
  "location": "Kogilu, Bengaluru",
  "category": "Delivery",
  "salary": "Rs. 35000 - Rs. 59000",
  "experience": "Fresher",
  "qualification": "< 10th Pass / Male Only",
  "postedText": "Posted on: 7/8/2026",
  "sourceUrl": "https://www.workindia.in/jobs-in-bengaluru/",
  "scrapedAt": "2026-07-08T00:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Add WorkIndia URLs or city/category slugs.
3. Choose `maxItems`.
4. Enable detail enrichment only if you need richer fields.
5. Start the run.
6. Download results as JSON, CSV, Excel, or via API.

### Tips for better results

- Use WorkIndia slugs exactly as they appear in URLs.
- Combine multiple city/category pages for larger datasets.
- Keep detail enrichment off for fast salary/category monitoring.
- Turn detail enrichment on for lead qualification or analytics.
- Use scheduled Apify tasks for recurring market monitoring.

### Limitations

WorkIndia listing pages usually expose a limited number of visible jobs per page.

For larger runs, provide multiple city or category pages.

The actor only returns information that WorkIndia exposes publicly in HTML or route data.

It does not bypass application forms, login walls, or candidate privacy controls.

### Integrations

Connect results to Google Sheets for recruiter review.

Send dataset items to Airtable for lead qualification.

Use webhooks to notify Slack when a scheduled run finishes.

Load CSV exports into BI tools for salary and category dashboards.

Use the Apify API to feed WorkIndia jobs into enrichment pipelines.

### API usage: Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/workindia-jobs-scraper').call({
  citySlugs: ['bengaluru'],
  categorySlugs: ['delivery'],
  maxItems: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage: Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/workindia-jobs-scraper').call(run_input={
    'citySlugs': ['mumbai'],
    'categorySlugs': ['telecalling'],
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage: cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~workindia-jobs-scraper/runs?token=<APIFY_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{"citySlugs":["bengaluru"],"categorySlugs":["delivery"],"maxItems":20}'
```

### MCP for Claude and AI agents

Use Apify MCP to call the actor directly from Claude Desktop, Claude Code, or another MCP-compatible tool.

MCP endpoint:

```text
https://mcp.apify.com/?tools=automation-lab/workindia-jobs-scraper
```

Claude Code setup:

```bash
claude mcp add apify-workindia-jobs "https://mcp.apify.com/?tools=automation-lab/workindia-jobs-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-workindia-jobs": {
      "url": "https://mcp.apify.com/?tools=automation-lab/workindia-jobs-scraper"
    }
  }
}
```

Example prompts:

- "Run WorkIndia Jobs Scraper for delivery jobs in Bengaluru and summarize salary ranges."
- "Scrape telecalling jobs in Mumbai and return companies with public postings."
- "Compare WorkIndia delivery postings across Bengaluru, Mumbai, and Delhi."

### Related scrapers

Other automation-lab actors can complement WorkIndia Jobs Scraper when building labor-market or lead datasets:

- `https://apify.com/automation-lab/google-maps-lead-finder`
- `https://apify.com/automation-lab/linkedin-jobs-scraper` if available in your account
- `https://apify.com/automation-lab/website-contact-finder`

Use WorkIndia Jobs Scraper when the target source is public WorkIndia job postings.

### Legality and ethical use

This actor extracts public job-posting information.

Use the data responsibly and follow applicable laws, platform terms, privacy rules, and fair-use principles.

Do not use it to collect private candidate data or circumvent access controls.

### Troubleshooting

#### Why did I get fewer jobs than `maxItems`?

A single WorkIndia listing page may expose only a limited number of jobs. Add more city/category URLs or slugs to collect more records.

#### Why are description and openings missing?

Enable `includeDetails`. Listing pages are faster but contain fewer fields than detail pages.

#### Why did a category URL return no jobs?

Check the category slug against WorkIndia's URL format. Some categories or city/category combinations may not exist.

### FAQ

#### Can I scrape multiple cities at once?

Yes. Add multiple `citySlugs` or multiple `startUrls`.

#### Can I scrape a single job page?

Yes. Put the job detail URL in `startUrls`.

#### Does the actor use a browser?

No. The default implementation uses HTTP and Cheerio because WorkIndia returns useful server-rendered HTML.

#### Does it return phone numbers?

No. The actor is scoped to public job-posting metadata and avoids private application/contact gates.

#### Can I schedule it?

Yes. Create an Apify task with your preferred input and schedule it daily, weekly, or hourly.

### Changelog

#### 0.1

Initial WorkIndia job-listing extraction with city/category URL generation, listing fields, and optional detail enrichment.

# Actor input Schema

## `startUrls` (type: `array`):

WorkIndia listing URLs (for example /jobs-in-bengaluru/ or /delivery-jobs-in-mumbai/) or individual job detail URLs.

## `citySlugs` (type: `array`):

Optional WorkIndia city slugs. The actor creates listing URLs like https://www.workindia.in/jobs-in-bengaluru/.

## `categorySlugs` (type: `array`):

Optional category slugs such as delivery, telecalling, accountant, field-sales, back-office, driver. Combined with city slugs.

## `maxItems` (type: `integer`):

Maximum job records to save. Use a low number for tests and raise it for market monitoring runs.

## `includeDetails` (type: `boolean`):

Fetch every job detail page to add description, openings, timings, address, salary bounds, and posted timestamp. Slower but richer.

## `requestDelayMs` (type: `integer`):

Polite delay used when detail enrichment is enabled.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.workindia.in/jobs-in-bengaluru/"
    },
    {
      "url": "https://www.workindia.in/delivery-jobs-in-bengaluru/"
    }
  ],
  "citySlugs": [
    "bengaluru",
    "mumbai",
    "delhi"
  ],
  "categorySlugs": [
    "delivery",
    "telecalling"
  ],
  "maxItems": 20,
  "includeDetails": false,
  "requestDelayMs": 250
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.workindia.in/jobs-in-bengaluru/"
        },
        {
            "url": "https://www.workindia.in/delivery-jobs-in-bengaluru/"
        }
    ],
    "citySlugs": [
        "bengaluru",
        "mumbai",
        "delhi"
    ],
    "categorySlugs": [
        "delivery",
        "telecalling"
    ],
    "maxItems": 20,
    "includeDetails": false,
    "requestDelayMs": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/workindia-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [
        { "url": "https://www.workindia.in/jobs-in-bengaluru/" },
        { "url": "https://www.workindia.in/delivery-jobs-in-bengaluru/" },
    ],
    "citySlugs": [
        "bengaluru",
        "mumbai",
        "delhi",
    ],
    "categorySlugs": [
        "delivery",
        "telecalling",
    ],
    "maxItems": 20,
    "includeDetails": False,
    "requestDelayMs": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/workindia-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.workindia.in/jobs-in-bengaluru/"
    },
    {
      "url": "https://www.workindia.in/delivery-jobs-in-bengaluru/"
    }
  ],
  "citySlugs": [
    "bengaluru",
    "mumbai",
    "delhi"
  ],
  "categorySlugs": [
    "delivery",
    "telecalling"
  ],
  "maxItems": 20,
  "includeDetails": false,
  "requestDelayMs": 250
}' |
apify call automation-lab/workindia-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WorkIndia Jobs Scraper",
        "description": "Extract public WorkIndia jobs by city, category, or URL with salary, company, locality, experience, qualification, and job links.",
        "version": "0.1",
        "x-build-id": "RZcDHwlNu8fnFzuDS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~workindia-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-workindia-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~workindia-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-workindia-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~workindia-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-workindia-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "WorkIndia listing URLs (for example /jobs-in-bengaluru/ or /delivery-jobs-in-mumbai/) or individual job detail URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "citySlugs": {
                        "title": "City slugs",
                        "type": "array",
                        "description": "Optional WorkIndia city slugs. The actor creates listing URLs like https://www.workindia.in/jobs-in-bengaluru/.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categorySlugs": {
                        "title": "Category slugs",
                        "type": "array",
                        "description": "Optional category slugs such as delivery, telecalling, accountant, field-sales, back-office, driver. Combined with city slugs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum job records to save. Use a low number for tests and raise it for market monitoring runs.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Enrich from detail pages",
                        "type": "boolean",
                        "description": "Fetch every job detail page to add description, openings, timings, address, salary bounds, and posted timestamp. Slower but richer.",
                        "default": false
                    },
                    "requestDelayMs": {
                        "title": "Delay between detail requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay used when detail enrichment is enabled.",
                        "default": 250
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
