# Kompass Company Directory Scraper (`automation-lab/kompass-company-directory-scraper`) Actor

Extract public Kompass company and supplier records by country, category, search, or profile URL for B2B sales, sourcing, procurement, and market research.

- **URL**: https://apify.com/automation-lab/kompass-company-directory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Kompass Company Directory Scraper

Extract structured public company and supplier records from Kompass country-directory URLs.

Use directory, category, search, and individual company profile URLs from multiple Kompass country domains in one run. The Actor returns company names, locations, descriptions, business activities, employee ranges, public websites, profile identifiers, and contact availability where those fields are publicly exposed.

### What this Actor does

Kompass Company Directory Scraper turns URL-driven supplier research into a reusable dataset.

It can:

- accept public Kompass URLs from multiple country domains;
- infer the country and search intent from each URL;
- paginate through matching company results;
- enrich directory cards with public profile fields;
- deduplicate companies across overlapping inputs;
- preserve useful card data when one detail page fails;
- stop at a global `maxItems` limit;
- export results as JSON, CSV, Excel, XML, or RSS through Apify.

The implementation uses server-rendered data from a public Kompass partner directory when direct Kompass HTML is protected by DataDome. It needs no browser or paid proxy traffic. Every row includes both the original `sourceUrl` and the exact `dataSourceUrl`, so data provenance stays explicit.

### Who is it for

#### B2B sales teams

Build prospect lists by country and business category, then send public company websites and addresses to a CRM enrichment step.

#### Sourcing and procurement analysts

Compare manufacturers and suppliers across markets without manually copying company cards.

#### Manufacturers and distributors

Research potential channel partners, vendors, and competitors in repeatable batches.

#### Import and export teams

Refresh country-specific supplier lists on a schedule and compare changes over time.

#### Market researchers

Create structured market maps with company, city, activity, and employee-range fields.

### Why use this Actor

- **URL driven:** start from the exact Kompass pages already used in your research.
- **Multi-country:** mix `us.kompass.com`, `gb.kompass.com`, and other two-letter country domains.
- **Partial-result safe:** directory-card records are retained if optional profile enrichment fails.
- **Transparent provenance:** input and extraction URLs are recorded separately.
- **Bounded:** global record and per-URL page limits prevent accidental unbounded crawls.
- **Typed output:** stable fields are ready for spreadsheets, databases, agents, and APIs.
- **Public scope only:** no EasyBusiness account, private export, or CAPTCHA solving is required.

### Supported Kompass URLs

The Actor accepts these public URL families:

1. Country manufacturer directories, for example:
   `https://us.kompass.com/x/producer/`
2. Category or activity pages, for example:
   `https://us.kompass.com/a/industrial-machinery/`
3. Search pages with `searchKeywords` or `q` query parameters.
4. Company profile pages, for example:
   `https://us.kompass.com/c/nasbite-international/us946509/`

The host must be a two-letter Kompass country domain. Login, cart, checkout, EasyBusiness, and export URLs are intentionally rejected or unsupported.

### Data extracted

| Field | Meaning |
| --- | --- |
| `companyName` | Public company name |
| `profileUrl` | Public extracted profile URL, or the canonical Kompass URL for profile-only fallback |
| `companyId` | Public profile identifier when exposed |
| `verified` | Verification status, or `null` when not published |
| `city`, `country` | Public company location |
| `address`, `postalCode` | Public address fields |
| `description` | Public company description |
| `supplierActivities` | Business categories and supplier activities |
| `products` | Public product names when available |
| `employeeRange` | Published employee-count band |
| `rating`, `reviewCount` | Public partner-directory review information |
| `phone`, `email` | Public values when exposed without login |
| `phoneAvailable`, `emailAvailable` | Whether the public profile exposed the contact field |
| `website` | Public company website |
| `sourceUrl` | Original Kompass input URL |
| `dataSourceUrl` | Exact page used to extract the record |
| `scrapedAt` | ISO 8601 extraction timestamp |

Unavailable fields are returned as `null` or an empty array. The Actor never invents contact data.

### Getting started

1. Open the Actor in Apify Console.
2. Add one or more public Kompass URLs.
3. Keep `maxItems` small for your first run.
4. Leave **Enrich company profiles** enabled for descriptions, addresses, and websites.
5. Set a page safety limit for each input URL.
6. Start the run.
7. Open the **Companies** dataset view.
8. Export the results or connect the dataset to your workflow.

A small input:

```json
{
  "startUrls": [
    { "url": "https://us.kompass.com/x/producer/" }
  ],
  "maxItems": 25,
  "includeDetails": true,
  "maxPagesPerUrl": 3
}
````

### Input parameters

#### `startUrls`

Required array of public Kompass URLs. Strings and request-list objects with a `url` field are supported by the Apify input editor.

#### `maxItems`

Maximum unique companies saved across all URLs.

- default: `25`
- minimum: `1`
- maximum: `10000`

#### `includeDetails`

When `true`, the Actor fetches public profile HTML to add description, address, postal code, website, verification, products, and detailed categories.

When `false`, it returns faster card-level records. Fields available only on detail pages remain `null`.

#### `maxPagesPerUrl`

Pagination safety limit applied separately to every directory, category, or search URL.

- default: `10`
- minimum: `1`
- maximum: `100`

### Output example

A representative current record looks like this:

```json
{
  "companyName": "Example Industrial Systems LLC",
  "profileUrl": "https://www.b2bstars.com/en-us/kompass/company/example-industrial-systems-llc",
  "companyId": "1234567",
  "verified": null,
  "city": "Springfield",
  "country": "US",
  "address": "100 Example Avenue",
  "postalCode": "12345",
  "description": "Supplier of industrial automation equipment and maintenance services.",
  "supplierActivities": [
    "Manufacturing",
    "Industrial machinery"
  ],
  "products": [],
  "employeeRange": "50-99",
  "rating": 4,
  "reviewCount": 42,
  "phone": null,
  "phoneAvailable": false,
  "email": null,
  "emailAvailable": false,
  "website": "https://www.example.com",
  "sourceUrl": "https://us.kompass.com/x/producer/",
  "dataSourceUrl": "https://www.b2bstars.com/en-us/kompass/company/example-industrial-systems-llc",
  "scrapedAt": "2025-01-15T12:00:00.000Z"
}
```

The example is anonymized. Actual output reflects public source values.

### Pricing

This Actor uses pay-per-event pricing.

| Event | Price |
| --- | ---: |
| Run start | $0.005 per run |
| Company record, Free plan | $0.00016963 per record |
| Company record, Bronze plan | $0.00014751 per record |
| Company record, Silver plan | $0.00011506 per record |
| Company record, Gold plan | $0.000088504 per record |

Higher Apify plans receive lower per-record tiers shown in Console.

Examples before Apify platform usage charges:

- 25 records on Free: about `$0.00924`
- 100 records on Free: about `$0.02196`
- 1,000 records on Bronze: about `$0.15251`

A record is charged only after it is saved to the dataset. Optional detail enrichment does not create a second record charge.

### Accuracy and completeness

Kompass coverage and public fields vary by company and country.

- A directory card may contain only name, city, country, and category.
- A public partner profile may add description, address, website, and employee range.
- Phone and email fields are often absent from anonymous pages.
- `verified` remains `null` when verification is not published by the extraction surface.
- `products` remains empty when no public product list is exposed.
- A canonical profile URL not found on the partner surface produces a useful identity record from its public slug, country, and company ID.

Use null-aware processing downstream.

### Pagination, limits, and deduplication

`maxItems` is global. If the first URL reaches the limit, later URLs are not visited.

`maxPagesPerUrl` prevents one broad directory from consuming an unbounded run.

Deduplication uses normalized company name plus country. Overlapping category URLs therefore do not normally create duplicate dataset rows.

### Failure behavior

Malformed URLs and unsupported hosts fail with a non-zero exit code.

Transient profile failures preserve card-level data and emit a warning.

A run fails rather than silently succeeding with zero records when no useful companies can be produced.

If an individual canonical profile is not available on the public partner directory, the Actor preserves its canonical Kompass identity fields and logs that enrichment was unavailable.

### Workflow ideas

#### Supplier-list refresh

Schedule the Actor weekly, export the dataset, and upsert rows into your procurement database by country and normalized company name.

#### CRM enrichment

Send `companyName`, `website`, `city`, and `supplierActivities` to HubSpot, Salesforce, or a custom CRM workflow.

#### Multi-country comparison

Combine equivalent category URLs from several Kompass country domains. Group results by `country` and `supplierActivities` in a spreadsheet or BI tool.

#### Website research pipeline

Pass non-null `website` values to a website contact finder or company-intelligence Actor.

#### AI supplier screening

Give an agent the typed descriptions and activity lists, then ask it to rank suppliers against sourcing criteria. Keep final procurement decisions under human review.

### Run with the Apify API

Set `APIFY_TOKEN` in your environment.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~kompass-company-directory-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://us.kompass.com/x/producer/"}],
    "maxItems": 25,
    "includeDetails": true,
    "maxPagesPerUrl": 3
  }'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/kompass-company-directory-scraper').call({
    startUrls: [{ url: 'https://us.kompass.com/x/producer/' }],
    maxItems: 25,
    includeDetails: true,
    maxPagesPerUrl: 3,
});

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

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/kompass-company-directory-scraper').call(run_input={
    'startUrls': [{'url': 'https://us.kompass.com/x/producer/'}],
    'maxItems': 25,
    'includeDetails': True,
    'maxPagesPerUrl': 3,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI agents

#### Claude Code

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/kompass-company-directory-scraper"
```

#### Claude Desktop

Add this remote MCP server to your Claude Desktop configuration:

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

#### Cursor

Open **Settings → Tools & MCP**, add a remote HTTP server, and use:

`https://mcp.apify.com?tools=automation-lab/kompass-company-directory-scraper`

#### VS Code

Add the same remote HTTP URL to your workspace MCP configuration, then enable the `automation-lab/kompass-company-directory-scraper` tool.

Example prompts:

- “Run the Kompass Company Directory Scraper for this US manufacturer URL and return 50 companies.”
- “Compare activity categories from these US and UK Kompass URLs.”
- “Extract the public profile identity for this Kompass company URL.”

### Integrations

Use Apify integrations to send completed datasets to:

- Google Sheets;
- Slack;
- Zapier;
- Make;
- webhooks;
- Amazon S3;
- GitHub Actions;
- custom applications through `apify-client`.

For large workflows, consume dataset pages incrementally instead of loading the full export into memory.

### Responsible use and legality

This Actor extracts public business-directory information.

You are responsible for:

- complying with applicable laws and website terms;
- using business contact information for a lawful purpose;
- honoring marketing consent and opt-out requirements;
- minimizing personal data;
- securing exported datasets;
- respecting intellectual-property and database rights.

The Actor does not access EasyBusiness, login-only exports, decision-maker records, or private credentials. Do not use it to circumvent access controls.

### Troubleshooting

#### “Unsupported host”

Use a public two-letter Kompass country domain such as `us.kompass.com` or `gb.kompass.com`.

#### “Unsupported Kompass URL shape”

Use a directory, category, search, or `/c/...` company profile URL. Login, checkout, and arbitrary pages are not supported.

#### Fewer fields than expected

Turn on `includeDetails`. Some companies still publish only partial anonymous information; null fields are expected.

#### A profile returned only identity fields

The canonical profile was not indexed by the public partner directory. The Actor preserved the name slug, country, profile URL, and public company ID rather than inventing details.

#### No records

Check that the URL describes a real public company/category, reduce filters, and inspect the run log. The Actor fails empty runs so automation can detect them.

### Related Automation Lab Actors

- [Europages Supplier Scraper](https://apify.com/automation-lab/europages-supplier-scraper) for another European B2B supplier directory.
- [Made-in-China Scraper](https://apify.com/automation-lab/made-in-china-scraper) for manufacturer and product research.
- [Global Sources Supplier Product Scraper](https://apify.com/automation-lab/global-sources-supplier-product-scraper) for supplier and product discovery.

Use related sources when you need broader marketplace coverage, then deduplicate by company website and normalized name.

### FAQ

#### Does it require a Kompass account?

No. The Actor is limited to anonymous public fields.

#### Does it scrape EasyBusiness exports or decision makers?

No. Paid exports, login-only records, and private decision-maker data are out of scope.

#### Can I use multiple countries in one run?

Yes. Add URLs from multiple two-letter Kompass country domains to `startUrls`.

#### Does `maxItems` apply per URL?

No. It is the global dataset limit. `maxPagesPerUrl` is the per-URL safety limit.

#### Why is `profileUrl` sometimes a partner-directory URL?

Direct Kompass HTML is protected by DataDome. The Actor uses a public Kompass partner directory and records the exact extraction page in `dataSourceUrl`. For unmatched profile inputs, the canonical Kompass URL is retained.

#### Are phone numbers and emails guaranteed?

No. They are returned only when publicly visible without login. Use `phoneAvailable` and `emailAvailable` to distinguish an observed absence from unavailable card-level enrichment.

#### Can I schedule recurring runs?

Yes. Use Apify schedules and a webhook or integration to process each completed dataset.

#### Is the output stable?

Field names and types are stable, but source completeness varies. Build downstream logic that accepts `null` and empty arrays.

# Actor input Schema

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

Public Kompass country-directory, category, search, or company profile URLs. You can mix country domains in one run.

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

Maximum number of unique company records saved across all input URLs.

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

Fetch public partner profiles to add description, address, postal code, website, verification, product, and activity fields. Disable for faster card-level output.

## `maxPagesPerUrl` (type: `integer`):

Safety limit for pagination from each directory, category, or search URL.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://us.kompass.com/x/producer/"
    }
  ],
  "maxItems": 10,
  "includeDetails": true,
  "maxPagesPerUrl": 3
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all extracted company records.

# 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://us.kompass.com/x/producer/"
        }
    ],
    "maxItems": 10,
    "includeDetails": true,
    "maxPagesPerUrl": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/kompass-company-directory-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://us.kompass.com/x/producer/" }],
    "maxItems": 10,
    "includeDetails": True,
    "maxPagesPerUrl": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/kompass-company-directory-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://us.kompass.com/x/producer/"
    }
  ],
  "maxItems": 10,
  "includeDetails": true,
  "maxPagesPerUrl": 3
}' |
apify call automation-lab/kompass-company-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kompass Company Directory Scraper",
        "description": "Extract public Kompass company and supplier records by country, category, search, or profile URL for B2B sales, sourcing, procurement, and market research.",
        "version": "0.1",
        "x-build-id": "qzXuBrpooLx600x2y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~kompass-company-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-kompass-company-directory-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~kompass-company-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-kompass-company-directory-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~kompass-company-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-kompass-company-directory-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Kompass URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Public Kompass country-directory, category, search, or company profile URLs. You can mix country domains in one run.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum companies",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique company records saved across all input URLs.",
                        "default": 25
                    },
                    "includeDetails": {
                        "title": "Enrich company profiles",
                        "type": "boolean",
                        "description": "Fetch public partner profiles to add description, address, postal code, website, verification, product, and activity fields. Disable for faster card-level output.",
                        "default": true
                    },
                    "maxPagesPerUrl": {
                        "title": "Maximum pages per URL",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety limit for pagination from each directory, category, or search URL.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```