# SaaSworthy Software Directory Scraper (`automation-lab/saasworthy-software-directory-scraper`) Actor

Extract public SaaSworthy software profiles, pricing plans, features, ratings, review sentiment, alternatives, and vendor metadata for market intelligence.

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

## SaaSworthy Software Directory Scraper

Extract structured software profiles, pricing plans, features, ratings, review sentiment, alternatives, and vendor metadata from SaaSworthy.

Use product URLs for exact lookups or category slugs to build a market map. Each output row is a rich software-product record ready for spreadsheets, BI tools, databases, agents, and scheduled monitoring.

### What does SaaSworthy Software Directory Scraper do?

The Actor visits public SaaSworthy product and category pages and turns them into consistent JSON records.

It collects:

- software name, slug, URL, tagline, and description
- primary software category
- SW Score and component scores
- aggregate user rating and rating count
- rating distribution
- pricing summary, free-plan, and free-trial signals
- named pricing plans, prices, billing periods, and plan features
- product feature lists
- supported platforms and organization types
- API and support availability
- suggested alternatives
- positive and negative review sentiment topics
- review summary, pros, and cons
- logo, screenshots, and buyer FAQs

### Who is it for?

#### Product marketers

Track competitor positioning, plan packaging, feature claims, and review sentiment.

#### SaaS founders

Map a category before entering a market or changing pricing.

#### Analysts and investors

Build repeatable software-category datasets for market and deal research.

#### Content and SEO teams

Create evidence-backed comparison tables, alternatives pages, and software roundups.

#### Procurement teams

Collect comparable product, plan, feature, and rating data before shortlisting tools.

#### Data engineers

Feed normalized SaaSworthy records into warehouses, dashboards, and enrichment pipelines.

### Why use this SaaSworthy scraper?

Copying product pages by hand is slow and difficult to refresh.

This Actor provides:

- exact product lookup by URL or slug
- category-level product discovery
- consistent field names across products
- nested pricing plans and alternatives
- bounded retries for traffic challenges
- optional Apify Proxy configuration
- JSON, CSV, Excel, XML, and RSS exports
- scheduled runs and webhook integrations
- pay-per-event pricing that scales with produced records

### What data can I extract?

| Field | Description |
|---|---|
| `name` | Software product name |
| `slug` | Canonical SaaSworthy product slug |
| `productUrl` | Public source URL |
| `tagline` | Product positioning statement |
| `description` | SaaSworthy product overview |
| `category` | Primary software category |
| `swScore` | SaaSworthy ranking score |
| `scoreBreakdown` | Feature, review, momentum, and popularity components |
| `rating` | Displayed user rating |
| `ratingCount` | Number of displayed ratings |
| `ratingDistribution` | Excellent through terrible percentages |
| `pricingSummary` | Trial and starting-price summary |
| `hasFreeTrial` | Whether a free trial is advertised |
| `hasFreePlan` | Whether a free plan/freemium offer is advertised |
| `pricingPlans` | Plan names, prices, billing periods, descriptions, features |
| `features` | Product capabilities listed by SaaSworthy |
| `platforms` | Browser, mobile, and desktop availability |
| `organizationTypes` | Supported company sizes and user types |
| `apiSupport` | Displayed API availability |
| `supportModes` | Online and other support modes |
| `alternatives` | Related products with canonical URLs |
| `positiveSentiments` | Positive themes from review analysis |
| `negativeSentiments` | Negative themes from review analysis |
| `reviewSummary` | Source review summary |
| `pros` | Summarized advantages |
| `cons` | Summarized drawbacks |
| `logoUrl` | Product logo URL |
| `screenshotUrls` | Product screenshot URLs |
| `faqs` | Buyer questions and answers |
| `scrapedAt` | UTC extraction time |

### How to scrape SaaSworthy product profiles

1. Open the Actor in Apify Console.
2. Add one or more product URLs or slugs.
3. Set a small maximum for the first run.
4. Leave proxy disabled unless your network is challenged.
5. Click **Start**.
6. Review the records in the **SaaSworthy software products** view.
7. Export or integrate the default dataset.

Example product input:

```json
{
  "productUrls": ["slack", "asana"],
  "maxItems": 2,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

### How to scrape a SaaSworthy category

Use the part after `/list/` in a category URL.

For example:

```json
{
  "categories": ["project-management-software"],
  "maxItems": 20,
  "maxPagesPerCategory": 2
}
```

The Actor discovers canonical product links and then opens each product profile.

To control run duration:

- reduce `maxItems`
- reduce `maxPagesPerCategory`
- split large category portfolios into scheduled tasks
- use exact product slugs when discovery is unnecessary

### Input reference

#### `productUrls`

An array of full SaaSworthy product URLs or bare slugs.

Accepted examples:

- `slack`
- `asana`
- `https://www.saasworthy.com/product/slack`

#### `categories`

An array of SaaSworthy category slugs or list URLs.

Examples:

- `project-management-software`
- `crm-software`
- `business-instant-messaging-software`

#### `startUrls`

A mixed list of exact SaaSworthy product and list URLs.

#### `maxItems`

Maximum product records across all sources. Default: `10`.

#### `maxPagesPerCategory`

Maximum listing pages visited for each category. Default: `2`.

#### `proxyConfiguration`

Optional Apify Proxy settings. Direct browser access is the default and avoids unnecessary proxy bandwidth.

### Output example

```json
{
  "name": "Slack",
  "slug": "slack",
  "productUrl": "https://www.saasworthy.com/product/slack",
  "category": "Business Instant Messaging Software",
  "swScore": 98,
  "rating": 3.7,
  "ratingCount": 338,
  "hasFreeTrial": true,
  "hasFreePlan": true,
  "pricingPlans": [
    {
      "name": "Pro",
      "price": "$4.38",
      "billingPeriod": "per user / month",
      "features": ["Unlimited message history", "Unlimited app integrations"]
    }
  ],
  "positiveSentiments": ["Real-time Messaging", "Extensive Integrations"],
  "negativeSentiments": ["Storage Limitations", "Notification Overload"],
  "scrapedAt": "2026-07-14T00:00:00.000Z"
}
```

Source fields vary by product. Missing source sections are returned as empty arrays or `null` rather than invented values.

### How much does it cost to scrape SaaSworthy?

The Actor uses pay-per-event pricing:

- a small one-time **Start** event per run
- a **Software product extracted** event for each saved product
- tier discounts reduce the per-product event price on larger Apify plans

The current event price is displayed before each run in Apify Console.

Browser compute and optional proxy usage are billed separately by Apify. Keep first runs small to measure your workflow.

A run with exact product slugs is usually cheaper than a category crawl because it skips listing discovery.

### Pricing intelligence workflow

To monitor competitor plans:

1. Create one task with the target product slugs.
2. Set `maxItems` to the portfolio size.
3. Schedule the task daily or weekly.
4. Store each dataset in your warehouse.
5. Compare `pricingPlans`, `features`, and `scrapedAt` over time.
6. Trigger a webhook when a plan name, price, or feature list changes.

The Actor captures source data; your downstream workflow decides what counts as a meaningful change.

### Market mapping workflow

To create a category map:

1. Start from one or more category slugs.
2. Collect product names, URLs, ratings, SW Scores, and alternatives.
3. Use alternatives as relationship edges.
4. Group products by pricing model and feature coverage.
5. Refresh the map on a schedule.

This is useful for product strategy, market reports, acquisition scouting, and competitive content.

### Tips for reliable runs

- Start with one known product such as `slack`.
- Prefer canonical SaaSworthy URLs.
- Avoid setting large limits before a small validation run.
- Use category discovery only when you need multiple products.
- Do not enable a residential proxy by default.
- If the site challenges your network, configure Apify Proxy and retry.
- Schedule conservative batches instead of one oversized run.
- Treat pricing details as source observations, not guaranteed vendor quotes.
- Confirm high-stakes purchasing decisions on the vendor website.

### Handling errors and missing data

The Actor retries challenged navigation with fresh browser state.

If one product fails:

- the failure is logged
- other products continue
- no empty shell record is saved

A run fails when every requested product is invalid or inaccessible. This protects downstream systems from treating empty pages as real products.

Some products do not publish:

- pricing plans
- rating distribution
- review sentiment
- FAQs
- screenshots

Those fields remain empty or `null`.

### Integrations

#### Google Sheets

Use the Apify Google Sheets integration to refresh a software comparison workbook.

#### Webhooks

Send a dataset-ready webhook to your change-detection or alerting service.

#### Zapier and Make

Trigger CRM updates, competitive-intelligence tickets, or content briefs after a scheduled run.

#### Data warehouses

Pull dataset items into BigQuery, Snowflake, PostgreSQL, or your object store.

#### Slack and email alerts

Compare the newest record with the previous run and notify a team when pricing or sentiment changes.

### Run with the Apify API using cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~saasworthy-software-directory-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productUrls":["slack"],"maxItems":1}'
```

Fetch dataset items after the run finishes:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Run with the Apify API using Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/saasworthy-software-directory-scraper').call({
  productUrls: ['slack', 'asana'],
  maxItems: 2,
});

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

### Run with the Apify API using Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/saasworthy-software-directory-scraper').call(
    run_input={
        'categories': ['project-management-software'],
        'maxItems': 10,
        'maxPagesPerCategory': 1,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI assistants

Connect the Actor through Apify MCP:

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

In Claude Code, add the hosted server:

```bash
claude mcp add --transport http apify https://mcp.apify.com/?tools=automation-lab/saasworthy-software-directory-scraper
```

#### Claude Desktop setup

#### Cursor setup

#### VS Code setup

Claude Desktop and Cursor can use this `mcpServers` configuration (supply authentication using your environment or client settings):

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

VS Code users can add the same HTTP URL from the MCP server settings. Authenticate the Apify MCP connection with your Apify token.

Example prompts:

- “Extract Slack and Asana pricing, features, ratings, and sentiment from SaaSworthy.”
- “Build a ten-product map of project management software.”
- “Compare the free plans and negative review themes of these SaaS competitors.”
- “Run my SaaSworthy competitor portfolio task and summarize pricing changes.”

AI output should cite the source records and avoid inventing unavailable fields.

### Scheduling and monitoring

Apify tasks preserve a tested input configuration.

Recommended schedules:

- daily for high-priority competitor pricing
- weekly for product and sentiment monitoring
- monthly for broad category maps

Use a stable product list for clean comparisons. Category membership can naturally change between runs.

### Data quality and limitations

SaaSworthy is a third-party software directory.

The Actor reports what the public source displays at extraction time.

Important limitations:

- source data may be vendor-entered or summarized
- rating counters may differ between page sections
- plan prices can be localized or outdated
- products may omit optional sections
- anti-bot rules can change
- a public profile can move to another slug

For procurement or financial decisions, verify details with the software vendor.

### Is it legal to scrape SaaSworthy?

This Actor extracts publicly available pages without logging in.

You are responsible for:

- following applicable laws
- respecting website terms
- avoiding personal-data misuse
- choosing reasonable run frequency
- using the output for a lawful purpose

Do not use the Actor to bypass access controls or collect private account data.

### FAQ

#### Does this Actor need a SaaSworthy account?

No. It uses public product and category pages.

#### Does it scrape individual user reviews?

It extracts aggregate ratings, rating distribution, sentiment topics, review summary, pros, and cons from the product profile. It does not emit individual reviewer records.

#### Can I scrape multiple categories?

Yes. Add several category slugs and set a combined `maxItems` cap.

#### Why did a product return no record?

The URL may be invalid, redirected to a generic page, temporarily challenged, or missing a real SaaSworthy product profile. Check the run log and test the canonical URL in a browser.

#### Why is a pricing plan missing?

Not every product publishes structured plans. SaaSworthy can also show only a starting-price summary.

#### Can I use a proxy?

Yes. Configure `proxyConfiguration` in the Actor input. Start without one, then enable it only when required.

#### Can I export CSV or Excel?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and other formats.

#### How do I avoid duplicates?

The Actor canonicalizes discovered product URLs and saves each product once per run.

### Related scrapers

Combine this Actor with other automation-lab tools:

- [G2 Scraper](https://apify.com/automation-lab/g2-scraper) for software product and review intelligence
- [Trustpilot Scraper](https://apify.com/automation-lab/trustpilot-scraper) for company review monitoring
- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) for local-business research

Use only the sources needed for your workflow and reconcile entities by canonical website domain where possible.

### Support

If a public SaaSworthy page works in your browser but fails in the Actor, open an issue from the Actor page.

Include:

- the exact input
- the run URL
- the affected SaaSworthy URL
- the expected field or record

This makes reproduction and repair faster.

# Actor input Schema

## `productUrls` (type: `array`):

SaaSworthy product URLs or slugs such as slack and asana.

## `categories` (type: `array`):

SaaSworthy list slugs such as project-management-software. Product pages from each category are discovered automatically.

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

Product URLs and/or SaaSworthy list pages.

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

Maximum number of product records saved across all inputs.

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

Maximum listing pages followed for each category URL.

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

Optional Apify Proxy settings. Leave disabled unless your network is challenged by SaaSworthy.

## Actor input object example

```json
{
  "productUrls": [
    "slack"
  ],
  "categories": [],
  "startUrls": [],
  "maxItems": 3,
  "maxPagesPerCategory": 1,
  "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 = {
    "productUrls": [
        "slack"
    ],
    "categories": [],
    "startUrls": [],
    "maxItems": 3,
    "maxPagesPerCategory": 1,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/saasworthy-software-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 = {
    "productUrls": ["slack"],
    "categories": [],
    "startUrls": [],
    "maxItems": 3,
    "maxPagesPerCategory": 1,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/saasworthy-software-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 '{
  "productUrls": [
    "slack"
  ],
  "categories": [],
  "startUrls": [],
  "maxItems": 3,
  "maxPagesPerCategory": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/saasworthy-software-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SaaSworthy Software Directory Scraper",
        "description": "Extract public SaaSworthy software profiles, pricing plans, features, ratings, review sentiment, alternatives, and vendor metadata for market intelligence.",
        "version": "0.1",
        "x-build-id": "bDpbFDSRmUnT8lNOX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~saasworthy-software-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-saasworthy-software-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~saasworthy-software-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-saasworthy-software-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~saasworthy-software-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-saasworthy-software-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",
                "properties": {
                    "productUrls": {
                        "title": "🎯 Product URLs or slugs",
                        "type": "array",
                        "description": "SaaSworthy product URLs or slugs such as slack and asana.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "📚 Category slugs",
                        "type": "array",
                        "description": "SaaSworthy list slugs such as project-management-software. Product pages from each category are discovered automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Product URLs and/or SaaSworthy list pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum software products",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of product records saved across all inputs.",
                        "default": 10
                    },
                    "maxPagesPerCategory": {
                        "title": "Maximum pages per category",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum listing pages followed for each category URL.",
                        "default": 2
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Leave disabled unless your network is challenged by SaaSworthy.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```