# Crozdesk Category Software Listings Scraper (`automation-lab/crozdesk-category-software-listings-scraper`) Actor

Extract Crozdesk software listings with ratings, Crozscores, pricing snippets, descriptions, logos, vendor websites, and profile links.

- **URL**: https://apify.com/automation-lab/crozdesk-category-software-listings-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

from $0.06 / 1,000 software listings

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

## Crozdesk Category Software Listings Scraper

Extract structured software listings from public Crozdesk category pages.

This Apify Actor collects product names, Crozdesk profile links, vendor website links, descriptions, Crozscores, ratings, pricing snippets, logos, category metadata, and listing positions from Crozdesk category result pages.

It is designed for SaaS marketers, review operations teams, product researchers, market intelligence analysts, and sales teams that need a repeatable export of Crozdesk directory data without manual copy and paste.

### What this actor does

The actor visits one or more public Crozdesk category URLs.

For each category, it requests the category provider listing endpoint.

It parses software cards directly from server-rendered HTML.

It saves one dataset row per software listing.

It does not require a Crozdesk account.

It does not use a browser by default.

It is optimized for lightweight HTTP extraction.

### Typical use cases

Build a lead list of vendors in a Crozdesk category.

Monitor which software products appear in a category.

Compare category-level Crozscores and ratings.

Collect public Crozdesk profile URLs for enrichment in another system.

Track pricing snippets displayed on listing pages.

Create a market map for a SaaS category.

Export product logos and descriptions for internal research.

Find alternatives and competitor sets in adjacent software categories.

### Supported pages

Use public Crozdesk category pages such as:

`https://www.crozdesk.com/customer-service-crm/crm-software`

The actor converts each category URL into Crozdesk's public provider listing endpoint.

The actor is scoped to category listing pages.

It does not crawl individual software detail pages in the MVP.

This keeps the run reliable because some detail pages may block plain HTTP clients.

### Input

The actor accepts a small and practical input schema.

#### `startUrls`

Required.

A list of Crozdesk category URLs.

Each URL should point to a public category page.

Example:

```json
[
  { "url": "https://www.crozdesk.com/customer-service-crm/crm-software" }
]
````

#### `maxItems`

Optional.

Maximum number of software listings to save across all categories.

Default: `50`.

Use a small value for testing.

Use a larger value for complete category exports.

#### `maxPagesPerCategory`

Optional.

Maximum number of provider-list pages to request for each category URL.

Default: `3`.

Increase this value when you need deeper category coverage.

#### `proxyConfiguration`

Optional.

Proxy is disabled by default.

Most public category listing pages work without proxy.

Enable Apify Proxy only if your run environment is rate-limited.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.crozdesk.com/customer-service-crm/crm-software" }
  ],
  "maxItems": 100,
  "maxPagesPerCategory": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

### Output

The default dataset contains one row per software listing.

Each row is a structured JSON object.

The fields are stable and suitable for export to CSV, JSON, Excel, Google Sheets, or API consumers.

### Output fields

#### `sourceUrl`

The provider listing endpoint used for the row.

#### `categoryUrl`

The original Crozdesk category URL.

#### `categoryName`

The visible category name, for example `CRM Software`.

#### `categorySlug`

The category slug from the URL.

#### `providerPage`

The provider listing page number.

#### `position`

The listing position within the actor output.

#### `name`

The software product name.

#### `slug`

The Crozdesk software slug when available.

#### `profileUrl`

The public Crozdesk profile URL.

The actor records this URL but does not crawl it.

#### `websiteUrl`

The outbound vendor website URL exposed on the listing card.

#### `logoUrl`

The product logo URL.

#### `description`

The short listing-card description.

#### `crozscore`

The Crozdesk score visible on the listing.

#### `ratingValue`

The aggregate rating value when present.

#### `ratingCount`

The aggregate rating count when present.

#### `pricingText`

The pricing snippet shown on the listing card.

#### `pricingUrl`

The Crozdesk pricing URL exposed by the listing card.

#### `compareUrl`

The Crozdesk compare URL when present.

#### `awardText`

Award or badge text when visible in the listing card.

#### `scrapedAt`

The ISO timestamp when the item was scraped.

### Example output

```json
{
  "sourceUrl": "https://www.crozdesk.com/customer-service-crm/crm-software/providers?page=1",
  "categoryUrl": "https://www.crozdesk.com/customer-service-crm/crm-software",
  "categoryName": "CRM Software",
  "categorySlug": "crm-software",
  "providerPage": 1,
  "position": 1,
  "name": "Creatio CRM",
  "slug": "creatio-crm-0",
  "profileUrl": "https://www.crozdesk.com/software/creatio-crm-0",
  "websiteUrl": "https://www.creatio.com/",
  "logoUrl": "https://static.crozdesk.com/.../logo.png",
  "description": "Creatio is the only agentic CRM that has no-code and AI at its core.",
  "crozscore": 87,
  "ratingValue": 4.7,
  "ratingCount": 407,
  "pricingText": "From: $25.00/month premium only Creatio CRM Pricing",
  "pricingUrl": "https://www.crozdesk.com/software/creatio-crm-0/pricing",
  "compareUrl": "https://www.crozdesk.com/compare/creatio-crm-0",
  "awardText": null,
  "scrapedAt": "2026-06-11T09:29:30.022Z"
}
```

### How pagination works

Crozdesk category pages expose provider listing pages.

The actor starts at provider page `1` for each category.

It continues until one of these conditions is met:

- `maxItems` is reached.
- `maxPagesPerCategory` is reached.
- A provider page returns no listing cards.

This approach avoids infinite crawling.

It also gives you predictable run sizes.

### Performance

The actor uses HTTP requests and Cheerio parsing.

It does not launch a browser.

This keeps memory and compute usage low.

Default memory is 256 MB.

For most small and medium category exports, the default settings are sufficient.

### Reliability notes

Crozdesk category listing pages are public.

The actor is intentionally conservative.

It avoids detail-page enrichment because detail pages can be more restrictive.

If Crozdesk changes its listing HTML, field extraction may need an update.

The actor logs category and provider-page fetches so runs are easy to inspect.

### Proxy guidance

Start with proxy disabled.

If you see rate limiting or network blocks, enable Apify Proxy.

For normal category page extraction, residential proxy should not be necessary.

Use the cheapest proxy configuration that works for your workload.

### Data freshness

The actor reads Crozdesk at run time.

Every run reflects what was visible on Crozdesk during that run.

Use scheduled runs if you need ongoing monitoring.

Export the dataset after each scheduled run to keep historical snapshots.

### How to run and export Crozdesk software listings

1. Open the Apify Store page for `automation-lab/crozdesk-category-software-listings-scraper`.

2. Click **Try for free** or **Run** to open the actor input form.

3. Paste one or more Crozdesk category URLs into `startUrls`, such as `https://www.crozdesk.com/customer-service-crm/crm-software`.

4. Keep `maxItems` low for the first run, for example 20 listings, so you can confirm the category and output shape quickly.

5. Increase `maxPagesPerCategory` when you want deeper category coverage.

6. Leave proxy disabled for the first run unless your environment needs Apify Proxy.

7. Start the run and wait for the status to become **Succeeded**.

8. Open the run dataset, inspect the table view, and export the results as CSV, JSON, Excel, XML, or RSS from the Apify dataset export menu.

9. For repeat monitoring, create an Apify schedule from the Store page or actor detail page and export each run dataset to your reporting workflow.

### How much does it cost to scrape Crozdesk software listings?

This actor uses pay-per-event pricing, so cost depends on how many public software listings are saved.

There is a small start event per run.

There is one result event per software listing saved.

The BRONZE result price is $0.10 per 1,000 saved software listings.

Higher Apify subscription tiers receive lower per-listing prices through tiered PPE discounts.

Use a small `maxItems` value for testing, then increase limits once you know the category produces the data you need.

### Tips for best results

Use category URLs, not individual software profile URLs.

Keep `maxItems` low while testing.

Increase `maxPagesPerCategory` when you need deeper coverage.

Use multiple category URLs when building a cross-category market map.

Deduplicate downstream by `profileUrl` or `slug` if you combine overlapping categories.

### Limitations

The actor does not log in to Crozdesk.

The actor does not bypass account-only content.

The actor does not crawl `/software/...` detail pages.

The actor does not extract full reviews.

The actor does not guarantee every category has the same visible fields.

Fields that are absent on a listing are returned as `null`.

### Who is it for

This actor is useful for SaaS founders, product marketers, review management teams, sales operations teams, data analysts, and market intelligence researchers.

Use it when you need a structured category-level export from Crozdesk instead of a manual browser workflow.

It is especially helpful when comparing public software directory coverage across sources such as Crozdesk, G2, Capterra, Serchen, and other B2B software directories.

### API usage

You can run the actor from the Apify Console, Apify API, Apify CLI, or official API clients.

#### Node.js example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/crozdesk-category-software-listings-scraper').call({
  startUrls: [{ url: 'https://www.crozdesk.com/customer-service-crm/crm-software' }],
  maxItems: 20,
  maxPagesPerCategory: 2,
  proxyConfiguration: { useApifyProxy: false }
});

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

#### Python example

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/crozdesk-category-software-listings-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.crozdesk.com/customer-service-crm/crm-software'}],
    'maxItems': 20,
    'maxPagesPerCategory': 2,
    'proxyConfiguration': {'useApifyProxy': False},
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL example

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~crozdesk-category-software-listings-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{"url": "https://www.crozdesk.com/customer-service-crm/crm-software"}],
    "maxItems": 20,
    "maxPagesPerCategory": 2,
    "proxyConfiguration": {"useApifyProxy": false}
  }'
```

### Integrations

Use this actor as a data collection step in repeatable software-market workflows.

Common integration patterns include:

- **CRM enrichment**: export Crozdesk category listings to CSV, match by company or product name, and append profile URLs, ratings, Crozscore values, pricing snippets, and descriptions to account records.
- **Competitive intelligence dashboards**: schedule category runs, send dataset exports to a warehouse or spreadsheet, and track which products appear in each software category over time.
- **Lead research pipelines**: combine category listings with your own qualification rules, then route matching products to sales operations or partner research queues.
- **Product marketing research**: collect public positioning text, category metadata, rating counts, and pricing snippets before comparing Crozdesk visibility with other software directories.
- **AI analysis workflows**: call the actor from Apify API, Apify MCP, or an automation tool, then ask an LLM to cluster products, summarize positioning, or flag products missing from your internal database.

The dataset can be exported manually from Apify or consumed programmatically with the API examples below.

### MCP

The actor can be used from Apify MCP-compatible workflows by calling the actor with the same JSON input shown above.

Use MCP when you want an AI agent or automation workflow to collect fresh Crozdesk category data and then summarize, compare, or enrich the resulting dataset.

Keep limits small for interactive MCP sessions.

#### Claude Desktop MCP setup

If you use Claude Desktop or another MCP client, add Apify's MCP server and then call this actor by its full actor ID.

Example CLI setup:

```bash
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors automation-lab/crozdesk-category-software-listings-scraper
```

Example JSON MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--actors",
        "automation-lab/crozdesk-category-software-listings-scraper"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

#### Example prompts

- "Run the Crozdesk Category Software Listings Scraper for the CRM Software category and summarize the top products by Crozscore."
- "Collect 20 Crozdesk project management listings and return a table with product name, rating count, pricing text, and profile URL."
- "Compare Crozdesk CRM listings with my existing G2 export and identify products that appear only on Crozdesk."

### Legality

This actor extracts public category-listing data visible without logging in.

You are responsible for using the data in a lawful way and respecting Crozdesk terms, privacy rules, and applicable regulations.

Do not use the actor for spam, harassment, credential collection, or any activity that violates source-site policies.

### FAQ

#### Can I scrape reviews?

No.

This actor is for category software listings only.

#### Can I scrape software detail pages?

Not in this MVP.

Detail pages may block simple HTTP clients, so the actor records profile URLs without crawling them.

#### Can I run multiple categories at once?

Yes.

Add multiple Crozdesk category URLs to `startUrls`.

#### Can I export to CSV?

Yes.

Use the Apify dataset export options after the run completes.

### Troubleshooting

If the dataset is empty, verify that your URL is a Crozdesk category page.

If the run stops early, increase `maxPagesPerCategory` or `maxItems`.

If requests fail with HTTP errors, try enabling Apify Proxy.

If a field is null, Crozdesk likely did not show that field on the listing card.

### Responsible use

Scrape only public data.

Respect Crozdesk terms and applicable laws.

Use reasonable limits.

Do not overload the source website.

Use exported data for legitimate business, research, or analytics workflows.

### Related actors

- https://apify.com/automation-lab/g2-scraper
- https://apify.com/automation-lab/serchen-software-reviews-scraper

### Changelog

#### 0.1

Initial category-listing scraper.

Extracts public Crozdesk provider listing cards.

Outputs software names, URLs, descriptions, ratings, scores, pricing snippets, logos, and category metadata.

# Actor input Schema

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

Public Crozdesk category pages to scrape, for example a CRM, project management, HR, or marketing software category URL.

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

Maximum number of software listing records to save across all category URLs.

## `maxPagesPerCategory` (type: `integer`):

How many Crozdesk provider-list pages to request per category. Each page usually contains multiple listings.

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

Optional proxy settings. Leave disabled for normal Crozdesk category pages; enable Apify Proxy if your run environment is rate-limited.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.crozdesk.com/customer-service-crm/crm-software"
    }
  ],
  "maxItems": 20,
  "maxPagesPerCategory": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.crozdesk.com/customer-service-crm/crm-software"
        }
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "startUrls": [{ "url": "https://www.crozdesk.com/customer-service-crm/crm-software" }] }

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.crozdesk.com/customer-service-crm/crm-software"
    }
  ]
}' |
apify call automation-lab/crozdesk-category-software-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crozdesk Category Software Listings Scraper",
        "description": "Extract Crozdesk software listings with ratings, Crozscores, pricing snippets, descriptions, logos, vendor websites, and profile links.",
        "version": "0.1",
        "x-build-id": "XcwNyRL49S3bQqNIJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~crozdesk-category-software-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-crozdesk-category-software-listings-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~crozdesk-category-software-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-crozdesk-category-software-listings-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~crozdesk-category-software-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-crozdesk-category-software-listings-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": "🔗 Crozdesk category URLs",
                        "type": "array",
                        "description": "Public Crozdesk category pages to scrape, for example a CRM, project management, HR, or marketing software category URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum software listings",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of software listing records to save across all category URLs.",
                        "default": 20
                    },
                    "maxPagesPerCategory": {
                        "title": "Maximum listing pages per category",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many Crozdesk provider-list pages to request per category. Each page usually contains multiple listings.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Leave disabled for normal Crozdesk category pages; enable Apify Proxy if your run environment is rate-limited.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
