# LinkedIn Public Profile Search Scraper (`automation-lab/linkedin-public-profile-search-scraper`) Actor

Find public LinkedIn people profile URLs from keyword, title, company, and location searches. Export names, headlines, snippets, query, and rank.

- **URL**: https://apify.com/automation-lab/linkedin-public-profile-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 12 total users, 9 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 profile 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

## LinkedIn Public Profile Search Scraper

Find public LinkedIn people profile URLs from keyword, title, company, and location searches. This actor is built for top-of-funnel discovery: give it recruiter or sales queries and it returns public search-result metadata for LinkedIn `/in/` profiles.

It does **not** log in to LinkedIn, does **not** scrape private LinkedIn people search pages, and does **not** require cookies. The actor uses public search-result surfaces to discover profile URLs and useful snippets.

### What does LinkedIn Public Profile Search Scraper do?

LinkedIn Public Profile Search Scraper searches the public web for LinkedIn profile results that match your query.

Typical input queries include:

- `software engineer Berlin`
- `head of sales SaaS London`
- `founder fintech New York`
- `site:linkedin.com/in product manager climate tech`

For each public result, the actor saves:

- profile URL
- parsed name
- parsed headline or title
- best-effort company
- best-effort location
- public search snippet
- source query
- result rank
- timestamp

### Who is it for?

This actor is useful for teams that need repeatable profile discovery without maintaining their own SERP parser.

- 🧑‍💼 Recruiters building candidate sourcing lists
- 📣 SDRs searching for decision makers by role and market
- 🏢 Agencies preparing lead lists for niche campaigns
- 📊 Data teams enriching an existing company or keyword workflow
- 🧪 Growth teams testing ICP and persona keywords

Use this actor when you do not yet know the exact LinkedIn profile URLs. If you already have URLs and need profile enrichment, use a profile enrichment actor instead.

### Why use this actor?

LinkedIn's native people search is login-gated. Many workflows only need public profile discovery, not private LinkedIn data.

This actor focuses on the public discovery step:

- no LinkedIn account required
- no browser automation required
- transparent source query for each result
- deduped profile URLs
- simple dataset rows for CRM and spreadsheet workflows

### Public-search approach

The actor automatically adds `site:linkedin.com/in` to your queries by default.

That means a query like:

```text
software engineer Berlin
````

is executed as:

```text
site:linkedin.com/in software engineer Berlin
```

You can disable this if you want to write your own advanced query operators.

### Input

The input is intentionally small and search-focused.

```json
{
  "queries": [
    "software engineer Berlin",
    "head of sales SaaS London"
  ],
  "maxItems": 25,
  "maxPagesPerQuery": 2,
  "forceLinkedInSiteSearch": true,
  "market": "en-US",
  "requestDelayMillis": 1000
}
```

### Input fields

| Field | Type | Description |
| --- | --- | --- |
| `queries` | array | Search queries such as title, company, seniority, industry, and location. |
| `maxItems` | integer | Maximum profile results to save across all queries. |
| `maxPagesPerQuery` | integer | Maximum search result pages to inspect per query. |
| `forceLinkedInSiteSearch` | boolean | Adds `site:linkedin.com/in` unless already present. |
| `market` | string | Search localization code such as `en-US`, `en-GB`, or `de-DE`. |
| `requestDelayMillis` | integer | Polite delay between search result requests. |

### Output

Each dataset item represents one public LinkedIn profile search result.

```json
{
  "profileUrl": "https://www.linkedin.com/in/example-person/",
  "name": "Example Person",
  "headline": "Head of Sales - Example SaaS",
  "company": "Example SaaS",
  "location": "London",
  "snippet": "Experience: Example SaaS · Location: London...",
  "title": "Example Person - Head of Sales - Example SaaS | LinkedIn",
  "sourceQuery": "head of sales SaaS London",
  "normalizedQuery": "site:linkedin.com/in head of sales SaaS London",
  "searchEngine": "brave",
  "searchResultRank": 1,
  "pageNumber": 1,
  "resultUrl": "https://www.linkedin.com/in/example-person/",
  "scrapedAt": "2026-06-24T05:32:22.425Z"
}
```

### Output fields

| Field | Description |
| --- | --- |
| `profileUrl` | Normalized LinkedIn `/in/` profile URL. |
| `name` | Best-effort name parsed from the result title. |
| `headline` | Best-effort headline or job title. |
| `company` | Best-effort company when the title exposes one. |
| `location` | Best-effort location from the public snippet. |
| `snippet` | Public search result snippet. |
| `title` | Raw search result title. |
| `sourceQuery` | Original user query. |
| `normalizedQuery` | Query actually sent to search. |
| `searchEngine` | Search surface used by the actor. |
| `searchResultRank` | Deduped output rank. |
| `pageNumber` | Search results page inspected. |
| `resultUrl` | Cleaned result URL. |
| `scrapedAt` | ISO timestamp. |

### How much does it cost to search public LinkedIn profiles?

The actor uses live pay-per-event pricing on Apify. You pay one small run-start event plus one event for each profile result saved to the dataset.

| Event | When it is charged | Live price |
| --- | --- | --- |
| Actor start | Once when a run starts | $0.005 per run |
| Profile result | Per saved LinkedIn public profile result | Tiered by your Apify plan |

| Apify plan tier | Profile result price |
| --- | ---: |
| Free | $0.000054817 per result |
| Bronze | $0.000047667 per result |
| Silver | $0.000037180 per result |
| Gold | $0.000028600 per result |
| Platinum | $0.000019067 per result |
| Diamond | $0.000013347 per result |

Example costs using the Free tier price:

| Run size | Cost formula | Estimated cost |
| --- | --- | ---: |
| 25 profiles | $0.005 + 25 × $0.000054817 | ~$0.0064 |
| 100 profiles | $0.005 + 100 × $0.000054817 | ~$0.0105 |
| 1,000 profiles | $0.005 + 1,000 × $0.000054817 | ~$0.0598 |

Higher Apify plan tiers pay less per saved profile result. The actor stops charging per-item events when it stops saving new dataset rows.

### How to search LinkedIn profiles by role and location

1. Add one or more role/location queries.
2. Keep `forceLinkedInSiteSearch` enabled.
3. Start with `maxItems` 25-100.
4. Export the dataset to CSV, JSON, Google Sheets, or your CRM pipeline.

Example:

```json
{
  "queries": ["vp engineering healthcare Boston"],
  "maxItems": 50,
  "maxPagesPerQuery": 3
}
```

### How to search LinkedIn profiles by company

Use company names with a target role.

```json
{
  "queries": [
    "data engineer Snowflake Berlin",
    "product marketing manager Stripe London"
  ],
  "maxItems": 100
}
```

### Query tips

Better queries produce better leads.

- Add geography when location matters.
- Use seniority words such as `founder`, `director`, `vp`, or `head of`.
- Add niche terms such as `climate tech`, `B2B SaaS`, or `cybersecurity`.
- Split unrelated personas into separate queries.
- Keep broad discovery runs moderate, then refine.

### Integrations

The output works well with common Apify integrations.

- Export profile URLs to Google Sheets.
- Send datasets to Make or Zapier.
- Feed URLs into a separate LinkedIn profile enrichment actor.
- Join results with company-domain or email-pattern workflows.
- Store query/rank data in your warehouse for sourcing analytics.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/linkedin-public-profile-search-scraper').call({
  queries: ['head of sales SaaS London'],
  maxItems: 25,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/linkedin-public-profile-search-scraper").call(run_input={
    "queries": ["software engineer Berlin"],
    "maxItems": 25,
})
print(run["defaultDatasetId"])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~linkedin-public-profile-search-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries":["founder fintech New York"],"maxItems":25}'
```

### MCP usage

Use this actor from Apify MCP tools when you want to ask an AI assistant to build a lead list.

MCP endpoint:

```text
https://mcp.apify.com/?tools=automation-lab/linkedin-public-profile-search-scraper
```

Claude Code setup:

```bash
claude mcp add apify-linkedin-search "https://mcp.apify.com/?tools=automation-lab/linkedin-public-profile-search-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-linkedin-search": {
      "url": "https://mcp.apify.com/?tools=automation-lab/linkedin-public-profile-search-scraper"
    }
  }
}
```

Example prompts:

- "Find 50 public LinkedIn profile URLs for heads of sales at SaaS companies in London."
- "Search for Berlin software engineers and return profile URLs with snippets."
- "Create a sourcing list for fintech founders in New York."

### Legality and privacy

This actor is intended for public web search results. It does not bypass LinkedIn login, does not collect private LinkedIn account data, and does not require user cookies.

You are responsible for using the output lawfully, respecting applicable privacy rules, and honoring platform terms and outreach regulations.

### Limitations

Public search results are not the same as LinkedIn's internal people search.

- Search engines may omit, reorder, or localize results.
- Some snippets may be stale.
- Name, company, and location parsing is best effort.
- Direct profile enrichment is intentionally excluded from the MVP.
- Search engines can throttle unusually aggressive runs.

### Troubleshooting

If you get too few results:

- broaden the query
- increase `maxPagesPerQuery`
- try another `market`
- remove overly specific quoted phrases

If results look too broad:

- add location
- add seniority
- add industry keywords
- split multiple personas into separate queries

### Related scrapers

Related Automation Lab actors for the same buyer journey:

- https://apify.com/automation-lab/linkedin-profile-scraper
- https://apify.com/automation-lab/linkedin-profile-url-finder
- https://apify.com/automation-lab/company-domain-to-twitter-x-url-resolver
- https://apify.com/automation-lab/email-pattern-finder

Use this actor first for discovery, then use enrichment actors when you already have profile URLs.

### FAQ

#### Does this actor log in to LinkedIn?

No. It only uses public search-result surfaces.

#### Can it guarantee every matching LinkedIn profile?

No. Search engines rank and filter public results. Treat the output as a discovery list, not an exhaustive LinkedIn database.

#### Why are some fields null?

Search snippets vary. The actor always returns the profile URL and query metadata when a valid result is found; name, company, and location are best-effort parsed fields.

#### Can I use advanced search operators?

Yes. Leave `forceLinkedInSiteSearch` enabled for normal use, or disable it when you want full control over the query.

### Data quality checklist

Before using a large list, review a sample of results.

- Confirm profile URLs are relevant.
- Check whether the query is too broad.
- Deduplicate across campaigns if needed.
- Feed only relevant URLs into downstream enrichment.

### Operational notes

The actor is HTTP-based and lightweight. Default memory is 256 MB. The built-in request delay is conservative to avoid unnecessary throttling.

### Changelog

Initial version: public LinkedIn profile discovery via search-result surfaces with deduped `/in/` profile URLs, snippets, source query, rank, and parsed person metadata.

# Actor input Schema

## `queries` (type: `array`):

One or more recruiter or sales prospecting searches. Use job title, company, industry, seniority, and location keywords.

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

Maximum number of public LinkedIn profile search results to save across all queries.

## `maxPagesPerQuery` (type: `integer`):

Maximum search result pages to inspect for each query. Higher values may find more profiles but take longer.

## `forceLinkedInSiteSearch` (type: `boolean`):

Automatically prefixes queries with site:linkedin.com/in unless you already included a site operator.

## `market` (type: `string`):

Market/language code used for localized search results, such as en-US, en-GB, de-DE, fr-FR, or es-ES.

## `requestDelayMillis` (type: `integer`):

Polite delay between search result requests. Increase if the search engine starts throttling.

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

Apify Proxy is enabled by default to reduce search-engine throttling. Use datacenter/shared proxies unless you have a specific need for another group.

## Actor input object example

```json
{
  "queries": [
    "software engineer Berlin",
    "head of sales SaaS London"
  ],
  "maxItems": 20,
  "maxPagesPerQuery": 2,
  "forceLinkedInSiteSearch": true,
  "market": "en-US",
  "requestDelayMillis": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "queries": [
        "software engineer Berlin",
        "head of sales SaaS London"
    ],
    "maxItems": 20,
    "maxPagesPerQuery": 2,
    "forceLinkedInSiteSearch": true,
    "market": "en-US",
    "requestDelayMillis": 1000,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/linkedin-public-profile-search-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 = {
    "queries": [
        "software engineer Berlin",
        "head of sales SaaS London",
    ],
    "maxItems": 20,
    "maxPagesPerQuery": 2,
    "forceLinkedInSiteSearch": True,
    "market": "en-US",
    "requestDelayMillis": 1000,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/linkedin-public-profile-search-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 '{
  "queries": [
    "software engineer Berlin",
    "head of sales SaaS London"
  ],
  "maxItems": 20,
  "maxPagesPerQuery": 2,
  "forceLinkedInSiteSearch": true,
  "market": "en-US",
  "requestDelayMillis": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call automation-lab/linkedin-public-profile-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Public Profile Search Scraper",
        "description": "Find public LinkedIn people profile URLs from keyword, title, company, and location searches. Export names, headlines, snippets, query, and rank.",
        "version": "0.1",
        "x-build-id": "EaoEKYedgjdTOScAB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~linkedin-public-profile-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-linkedin-public-profile-search-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~linkedin-public-profile-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-linkedin-public-profile-search-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~linkedin-public-profile-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-linkedin-public-profile-search-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "People search queries",
                        "type": "array",
                        "description": "One or more recruiter or sales prospecting searches. Use job title, company, industry, seniority, and location keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum profiles",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of public LinkedIn profile search results to save across all queries.",
                        "default": 100
                    },
                    "maxPagesPerQuery": {
                        "title": "Search pages per query",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum search result pages to inspect for each query. Higher values may find more profiles but take longer.",
                        "default": 3
                    },
                    "forceLinkedInSiteSearch": {
                        "title": "Force LinkedIn /in profile search",
                        "type": "boolean",
                        "description": "Automatically prefixes queries with site:linkedin.com/in unless you already included a site operator.",
                        "default": true
                    },
                    "market": {
                        "title": "Search market",
                        "type": "string",
                        "description": "Market/language code used for localized search results, such as en-US, en-GB, de-DE, fr-FR, or es-ES.",
                        "default": "en-US"
                    },
                    "requestDelayMillis": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between search result requests. Increase if the search engine starts throttling.",
                        "default": 1000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy is enabled by default to reduce search-engine throttling. Use datacenter/shared proxies unless you have a specific need for another group.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
