# Linkedin Profile Scraper (`dineshwadhwani/linkedin-profile-scraper`) Actor

Extract LinkedIn job listings by role, skill, and location in **under 60 seconds** — no browser required, no bloat, production-ready.

- **URL**: https://apify.com/dineshwadhwani/linkedin-profile-scraper.md
- **Developed by:** [Dinesh Kumar Wadhwani](https://apify.com/dineshwadhwani) (community)
- **Categories:** AI, Agents, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Job Search Aggregator — LinkedIn + Naukri + Indeed

Search three of India's biggest job platforms in a single run. Get up to 100 deduplicated, structured job listings from LinkedIn, Naukri, and Indeed — ranked by platform, filtered by role, skill, and location, ready to pipe into any downstream system.

Built for developers, recruiters, and product teams who need comprehensive job market coverage without managing three separate scrapers, three different APIs, and three different data formats. One input. One dataset. All three platforms.

---

### Why this Actor

Most job scrapers cover one platform. The problem is that job postings are fragmented — a VP Engineering role at a Bangalore startup may appear on LinkedIn but not Naukri. A GCC hiring drive may post exclusively on Naukri. A remote AI role may only surface on Indeed. Covering one platform means missing the others.

This Actor runs all three in sequence, deduplicates results globally, and returns a single clean dataset with a consistent output schema across platforms.

| | This Actor | Running 3 separate actors |
|---|---|---|
| ⚙️ Input | One set of inputs | Three separate configurations |
| 🔁 Deduplication | Global — same job never appears twice | Per-platform only |
| 📦 Output schema | Consistent across all platforms | Different fields per platform |
| 💰 Overhead | One actor run | Three actor runs |
| 🧠 Memory | Sequential — one browser at a time | Parallel — 3× memory |
| 📊 Coverage | LinkedIn + Naukri + Indeed | Depends which you run |

---

### How it works

The Actor runs platforms **sequentially** to keep memory usage low — LinkedIn first (HTTP-only, no browser), then Naukri (Playwright + API interception), then Indeed (Playwright + DOM scraping). All results share a global deduplication pool using job IDs and URLs, so the same listing never appears twice regardless of which platform returned it.

**Result allocation (soft split):**
- LinkedIn: up to 40 jobs
- Naukri: up to 40 jobs
- Indeed: up to 20 jobs
- Total cap: 100 unique jobs

The split is soft — if LinkedIn finds fewer than 40 results for a niche search, the unused slots carry over to Naukri and Indeed automatically. The 100-job total cap is always the governing limit.

**Search strategy:**
Each role is searched independently per location. Skills are appended as separate search terms (not combined into a single AND query), so each skill is OR'd — a job only needs to match one skill to qualify. Results are deduplicated globally across all role × skill × location combinations.

For Naukri specifically, the actor applies a title-match filter after fetching results, since Naukri's keyword search returns jobs where the role appears anywhere in the description — not just the title. This ensures "Vice President" doesn't return ".Net Lead" jobs that mention a VP in the org chart.

**Time limit:**
A hard 4-minute cutoff applies across all three platforms combined. If the search runs long (slow proxies, large result sets), the actor stops cleanly and returns whatever has been collected to that point. This bounds cost and prevents users from waiting indefinitely.

---

### What it does per platform

#### LinkedIn
Uses Crawlee's `CheerioCrawler` (HTTP-only, no browser) against LinkedIn's guest `seeMoreJobPostings` endpoint. Fast, cheap, no rendering overhead. Returns 10 jobs per page.

#### Naukri
Uses `PlaywrightCrawler` to load Naukri's search page, then intercepts the internal `jobapi/v3/search` XHR response — the same JSON API call Naukri's own page fires internally. This captures structured data (salary bands, experience ranges, work mode, skills array) without scraping HTML. Falls back to DOM scraping if interception fails.

#### Indeed
Uses `PlaywrightCrawler` with browser fingerprinting to render Indeed India's JavaScript-heavy search results and scrapes job cards from the DOM. Requires residential proxies.

---

### Input

| Field | Type | Required | Limit | Description |
|---|---|---|---|---|
| `roles` | `string[]` | ✅ Yes | 3 | Job titles to search for (e.g. `"Vice President"`, `"Director Engineering"`) |
| `skills` | `string[]` | No | 3 | Supporting keywords (e.g. `"AI"`, `"GCC"`, `"SaaS"`) |
| `locations` | `string[]` | ✅ Yes | 3 | Indian cities or regions (e.g. `"Bangalore"`, `"Pune"`, `"Hyderabad"`) |
| `timeFrame` | `string` | No | — | How recently jobs were posted — see values below |

#### timeFrame values

| Value | Meaning | Recommended for |
|---|---|---|
| `""` | Any time | Broad searches, rare roles |
| `1` | Last 24 hours | Daily scheduled runs |
| `7` | Last 7 days | Most searches — good volume/freshness balance |
| `15` | Last 15 days | Senior roles (VP, Director) — fewer postings per day |

> 💡 **Tip for senior roles:** VP, Director, and Head-of roles are posted less frequently than junior roles. Use `timeFrame: "15"` or `timeFrame: "7"` for best results. `"1"` (last 24 hours) will return very few results for senior titles.

#### Example — VP Engineering roles across India's tech hubs

```json
{
  "roles": ["Vice President", "VP Engineering"],
  "skills": ["AI", "SaaS", "GCC"],
  "locations": ["Bangalore", "Pune", "Hyderabad"],
  "timeFrame": "7"
}
````

This runs searches for:

- `Vice President` in each location
- `Vice President AI` in each location
- `Vice President SaaS` in each location
- `Vice President GCC` in each location
- `VP Engineering` in each location
- (and so on)

All results deduplicated globally — if the same job appears on LinkedIn and Naukri, it is saved only once.

#### Example — Data science roles

```json
{
  "roles": ["Data Scientist", "ML Engineer"],
  "skills": ["Python", "PyTorch"],
  "locations": ["Bangalore", "Mumbai"],
  "timeFrame": "7"
}
```

#### Example — Daily senior leadership scan

```json
{
  "roles": ["Chief Technology Officer", "VP Engineering", "Head of Engineering"],
  "locations": ["Bangalore"],
  "timeFrame": "1"
}
```

***

### Output

All results are saved to a single Apify dataset with a consistent schema across platforms. Each record includes a `platform` field so you can filter, sort, or route by source.

```json
{
  "platform": "LinkedIn",
  "title": "Vice President of Engineering",
  "company": "Acme Corp",
  "location": "Bengaluru, Karnataka, India",
  "link": "https://www.linkedin.com/jobs/view/4426507200",
  "postedAt": "2026-06-28",
  "jobId": "4426507200",
  "matchedKeywords": "Vice President AI",
  "searchLocation": "Bangalore",
  "roles": ["Vice President"],
  "inputSkills": ["AI", "GCC", "SaaS"]
}
```

```json
{
  "platform": "Naukri",
  "jobId": "060726009380",
  "title": "Vice President - Technology",
  "company": "Barclays",
  "location": "Bengaluru",
  "experience": "15-20 Yrs",
  "salary": "25-50 Lakhs",
  "workMode": "Hybrid",
  "skills": ["Cloud", "AWS", "Leadership", "Microservices"],
  "postedAt": 1783324493706,
  "link": "https://www.naukri.com/barclays-jobs-careers-212359",
  "matchedKeywords": "Vice President",
  "searchLocation": "Bangalore",
  "roles": ["Vice President"],
  "inputSkills": ["AI", "GCC", "SaaS"]
}
```

```json
{
  "platform": "Indeed",
  "title": "Vice President, Product Engineering",
  "company": "Flipkart",
  "location": "Bengaluru, Karnataka",
  "url": "https://in.indeed.com/rc/clk?jk=fcc1e677b4ff9df1",
  "jobKey": "fcc1e677b4ff9df1",
  "matchedKeywords": "Vice President AI",
  "searchLocation": "Bangalore",
  "roles": ["Vice President"],
  "inputSkills": ["AI", "GCC", "SaaS"]
}
```

#### Output field reference

| Field | Platforms | Description |
|---|---|---|
| `platform` | All | `"LinkedIn"`, `"Naukri"`, or `"Indeed"` |
| `title` | All | Job title as listed |
| `company` | All | Hiring company name |
| `location` | All | Location as shown on the listing |
| `link` / `url` | All | Direct URL to the job posting |
| `jobId` / `jobKey` | All | Platform's internal job ID — used for deduplication |
| `postedAt` | All | Posting date (format varies by platform) |
| `matchedKeywords` | All | The exact search query that produced this result |
| `searchLocation` | All | Which of your input locations produced this result |
| `roles` | All | Echo of your input roles |
| `inputSkills` | All | Echo of your input skills |
| `experience` | Naukri only | Required experience range (e.g. `"10-15 Yrs"`) |
| `salary` | Naukri only | Salary band if disclosed — null if hidden (most listings) |
| `workMode` | Naukri only | `Work from office`, `Remote`, or `Hybrid` |
| `skills` | Naukri only | Skills array extracted from the job listing |

***

### Performance benchmarks

Tested on Apify platform, 1024 MB memory:

| Search | Timeframe | Results | Duration | Cost |
|---|---|---|---|---|
| 1 role · 3 skills · 3 locations | Last 7 days | 60–100 jobs | 2–4 minutes | ~$0.05–0.10 |
| 3 roles · 3 skills · 3 locations | Last 7 days | 80–100 jobs | 3–4 minutes | ~$0.08–0.12 |
| 1 role · no skills · 1 location | Last 24 hours | 20–50 jobs | 1–2 minutes | ~$0.02–0.04 |

> 💡 **Memory setting:** Set to **1024 MB** in your Apify actor settings. Naukri and Indeed require a full Playwright browser. 512 MB is insufficient and will cause memory pressure warnings and instability.

***

### Scheduling & automation

This Actor is designed to be called by an application or run on a schedule.

**Daily senior leadership scan (recommended):**

```
Cron: 0 7 * * *   (7am IST daily)
timeFrame: "1"    (last 24 hours — only fresh listings each day)
```

**Weekly deep scan:**

```
Cron: 0 8 * * 1   (8am IST every Monday)
timeFrame: "7"    (last 7 days — catch everything from the week)
```

Connect the output dataset to Google Sheets, a webhook, an ATS, or a downstream Apify Actor using Apify's integrations.

***

### Platform coverage notes

**LinkedIn** — Best for senior and global roles. Returns clean, structured data quickly via HTTP-only requests. No browser needed, lowest cost per result.

**Naukri** — Best for Indian market volume. Returns richer structured data (salary bands, experience, work mode, skills) via API interception. Applies title-match filtering to ensure role relevance — Naukri's keyword search is broad and can return description-matched results without filtering.

**Indeed India** — Supplementary coverage. Useful for roles that appear on Indeed but not LinkedIn or Naukri. Requires residential proxies and browser rendering — slowest and most resource-intensive of the three.

***

### Limitations

- Returns up to **100 unique jobs per run** across all three platforms combined.
- A **4-minute hard stop** applies across all platforms combined. If the search hits the time limit, the actor returns whatever has been collected to that point — no partial-run errors.
- Naukri **salary data is null for most listings** — Naukri allows companies to hide salary, and most do. This is a Naukri platform policy.
- Indeed results do **not include job descriptions** — only data visible on the search results card.
- LinkedIn results require no authentication and use the guest API — results may differ slightly from what a logged-in user sees.
- For very niche searches (rare role + specific skill + small city), fewer than 100 results is expected and correct — this reflects actual job market supply, not a scraper limitation.

***

### FAQ

**Why sequential and not parallel?**
Naukri and Indeed both require a Playwright browser (Chromium). Running two browsers simultaneously doubles peak memory usage (~2 GB). Sequential execution keeps memory at ~1 GB and avoids instability on Apify's standard infrastructure.

**Why does Naukri return fewer results than expected?**
Naukri's search is broad — it matches keywords anywhere in a job posting, including org-chart descriptions ("reports to Vice President"). The actor applies a title-match filter post-fetch to ensure only genuinely relevant roles are returned. This reduces noise at the cost of some volume. For higher volume, use a wider timeFrame (`"7"` or `"15"`).

**Can I search remote jobs?**
Yes — add `"Remote"` as one of your locations for LinkedIn and Indeed. Naukri remote jobs are filtered by work mode in the platform's own API, not by location keyword.

**Why is Indeed returning fewer results than LinkedIn?**
Indeed India has Cloudflare protection. The actor uses residential proxies and browser fingerprinting to bypass it, but Cloudflare may still throttle requests intermittently. Indeed is included for supplementary coverage, not as the primary source.

**Is this Actor maintained?**
Yes — actively maintained. If any platform changes its HTML structure or API format, an update ships promptly.

**Can I use this to feed an AI pipeline?**
Yes — the structured output (especially Naukri's salary, experience, skills, and work mode fields) is well-suited for LLM-based matching, summarisation, and classification workflows.

***

### Input schema reference

```json
{
  "roles": ["Vice President", "Director Engineering"],
  "skills": ["AI", "GCC"],
  "locations": ["Bangalore", "Pune", "Hyderabad"],
  "timeFrame": "7"
}
```

`timeFrame` values:

| Value | Meaning |
|---|---|
| `""` | Any time |
| `1` | Last 24 hours |
| `7` | Last 7 days |
| `15` | Last 15 days |

# Actor input Schema

## `profileUrls` (type: `array`):

Public LinkedIn profile URLs, e.g. https://www.linkedin.com/in/dineshkwadhwani/

## `liAtCookie` (type: `string`):

The li\_at cookie from a logged-in LinkedIn session (DevTools > Application > Cookies). Required for full data. Use a burner account, treat this as a secret, and rotate it periodically.

## `minDelaySecs` (type: `integer`):

Lower bound of the randomized human-paced delay.

## `maxDelaySecs` (type: `integer`):

Upper bound of the randomized human-paced delay.

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

Keep at 1 for a single account/session to avoid detection.

## Actor input object example

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/dineshkwadhwani/"
  ],
  "minDelaySecs": 20,
  "maxDelaySecs": 40,
  "maxConcurrency": 1
}
```

# Actor output Schema

## `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 = {
    "profileUrls": [
        "https://www.linkedin.com/in/dineshkwadhwani/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dineshwadhwani/linkedin-profile-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 = { "profileUrls": ["https://www.linkedin.com/in/dineshkwadhwani/"] }

# Run the Actor and wait for it to finish
run = client.actor("dineshwadhwani/linkedin-profile-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 '{
  "profileUrls": [
    "https://www.linkedin.com/in/dineshkwadhwani/"
  ]
}' |
apify call dineshwadhwani/linkedin-profile-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin Profile Scraper",
        "description": "Extract LinkedIn job listings by role, skill, and location in **under 60 seconds** — no browser required, no bloat, production-ready.",
        "version": "0.0",
        "x-build-id": "Px4iIA07esOT3NIXL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dineshwadhwani~linkedin-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dineshwadhwani-linkedin-profile-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/dineshwadhwani~linkedin-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dineshwadhwani-linkedin-profile-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/dineshwadhwani~linkedin-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dineshwadhwani-linkedin-profile-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": [
                    "profileUrls"
                ],
                "properties": {
                    "profileUrls": {
                        "title": "Profile URLs",
                        "type": "array",
                        "description": "Public LinkedIn profile URLs, e.g. https://www.linkedin.com/in/dineshkwadhwani/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "liAtCookie": {
                        "title": "li_at session cookie",
                        "type": "string",
                        "description": "The li_at cookie from a logged-in LinkedIn session (DevTools > Application > Cookies). Required for full data. Use a burner account, treat this as a secret, and rotate it periodically."
                    },
                    "minDelaySecs": {
                        "title": "Min delay between profiles (seconds)",
                        "type": "integer",
                        "description": "Lower bound of the randomized human-paced delay.",
                        "default": 20
                    },
                    "maxDelaySecs": {
                        "title": "Max delay between profiles (seconds)",
                        "type": "integer",
                        "description": "Upper bound of the randomized human-paced delay.",
                        "default": 40
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "type": "integer",
                        "description": "Keep at 1 for a single account/session to avoid detection.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
