# GetApp Software Scraper (`automation-lab/getapp-software-scraper`) Actor

Turn public GetApp product, category, and search pages into enriched software rows with pricing, ratings, features, integrations, and media.

- **URL**: https://apify.com/automation-lab/getapp-software-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **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

## GetApp Software Scraper

Extract structured software-product intelligence from public GetApp pages.

GetApp Software Scraper turns product, category, and search pages into clean dataset rows with pricing plans, ratings, review counts, features, integrations, descriptions, logos, screenshots, and canonical URLs.

Use it for competitive research, procurement, SaaS catalog enrichment, product marketing, and scheduled market snapshots—without copying details by hand.

### What does GetApp Software Scraper do?

The Actor accepts three useful GetApp routes:

- 🔗 **Product pages** for exact software enrichment
- 📚 **Category pages** for product discovery and detail extraction
- 🔎 **Search pages** for query-driven software discovery

Every discovered listing is opened as a product detail page before it is saved.

The result is one normalized row per software product, not a thin link list.

Individual review text is intentionally outside this version. The Actor extracts the overall rating and review count.

### Why scrape GetApp software data?

GetApp combines product positioning, buyer ratings, pricing, features, and integrations in one public catalog.

That makes it useful for workflows such as:

- comparing competitor packaging and prices;
- monitoring rating or review-count changes;
- building an internal approved-software catalog;
- enriching CRM or market-research records;
- tracking integration ecosystems;
- finding products in a category for further analysis.

Structured exports are easier to compare, filter, join, and schedule than browser tabs or spreadsheets maintained by hand.

### Who is it for?

#### SaaS competitive-intelligence teams

Capture repeat snapshots of named competitors and compare changes in positioning, plans, ratings, and integrations.

#### Product marketers

Research how alternatives describe their products, which capabilities they emphasize, and how they package plans.

#### Procurement and research teams

Collect comparable public product facts before shortlisting or evaluating software vendors.

#### Data and catalog teams

Enrich internal records with canonical GetApp URLs, media, ratings, features, and pricing metadata.

#### Developers and automation builders

Run the scraper through the Apify API, schedules, webhooks, Make, Zapier, or MCP.

### What data can you extract?

| Field | Description |
|---|---|
| `title` | Software product name |
| `shortDescription` | Search-friendly GetApp summary |
| `description` | Detailed public product description |
| `category` | GetApp breadcrumb category |
| `url` | Canonical product URL |
| `logoUrl` | Product logo URL |
| `mediaUrls` | Product screenshots or videos |
| `rating` | Overall numerical rating |
| `reviewCount` | Number of verified reviews |
| `hasFreePlan` | Whether a free version is shown |
| `hasFreeTrial` | Whether a free trial is shown |
| `pricingAvailable` | Whether public pricing is present |
| `startingPrice` | Displayed starting-price text |
| `pricingPlans` | Plan names, prices, periods, and included features |
| `features` | Public feature names |
| `integrationCount` | Number of integration names extracted |
| `integrations` | Public integration names |
| `sourceUrl` | Input URL that discovered the product |
| `scrapedAt` | ISO capture timestamp |

Fields absent on a source page are omitted instead of filled with misleading values.

### How to scrape GetApp products

1. Open the Actor input form.
2. Add one or more public `getapp.com` URLs.
3. Set a small `maxItems` for your first run.
4. Set `maxPagesPerUrl` when using a category or search page.
5. Run the Actor.
6. Preview the **Software products** dataset view.
7. Export JSON, CSV, Excel, XML, or another supported format.

A single product URL is the cheapest first test.

### Input

#### `startUrls`

Required list of public GetApp product, category, or search URLs.

Only HTTPS URLs on `getapp.com` are accepted. Invalid external URLs fail closed.

#### `maxItems`

Global maximum number of unique product rows to save.

The default is intentionally small for safe first runs.

#### `maxPagesPerUrl`

Maximum pagination depth for each discovery URL.

Product pages do not paginate.

#### `proxyCountryCode`

Two-letter residential proxy country code. The default is `US`.

#### `maxRetries`

Number of bounded browser-session rotations after a blocked or invalid page.

### Example input: one product

```json
{
  "startUrls": [
    { "url": "https://www.getapp.com/collaboration-software/a/slack/" }
  ],
  "maxItems": 1,
  "proxyCountryCode": "US",
  "maxRetries": 2
}
````

This extracts a single enriched Slack record.

### Example input: category discovery

```json
{
  "startUrls": [
    { "url": "https://www.getapp.com/collaboration-software/productivity/" }
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 2,
  "proxyCountryCode": "US",
  "maxRetries": 2
}
```

The Actor discovers product URLs and enriches each product before saving it.

### Example output

```json
{
  "title": "Slack",
  "shortDescription": "Interested in Slack? Read GetApp's full overview...",
  "category": "Productivity",
  "url": "https://www.getapp.com/collaboration-software/a/slack/",
  "rating": 4.663940535839993,
  "reviewCount": 24149,
  "hasFreePlan": true,
  "hasFreeTrial": true,
  "pricingAvailable": true,
  "startingPrice": "8.75",
  "pricingPlans": [
    {
      "name": "Pro",
      "price": 8.75,
      "billingPeriod": "/user Per month",
      "features": ["Unlimited message history", "Unlimited apps and integrations"]
    }
  ],
  "integrationCount": 186,
  "integrations": ["Google Drive", "Google Calendar", "Jira", "GitHub"],
  "sourceUrl": "https://www.getapp.com/collaboration-software/a/slack/",
  "scrapedAt": "2026-07-17T22:00:00.000Z"
}
```

The source changes over time, so exact values can differ between runs.

### How much does it cost to scrape GetApp software products?

This Actor uses pay-per-event pricing.

You pay a small run-start charge plus one result event for every unique software product saved.

The per-product price is **$0.074529 FREE, $0.064808 BRONZE, $0.05055 SILVER, $0.038885 GOLD, $0.025923 PLATINUM, or $0.018146 DIAMOND**. A run also has a $0.005 start event.

These formula-derived prices cover detail-page browser enrichment: full plan cards, large feature and integration sets, ratings, descriptions, and media URLs rather than thin category rows. Browser sessions and residential proxy traffic are included; there is no separate GetApp API key to buy.

Use `maxItems: 1` to estimate your account-specific price before running a category.

### Reliability and anti-blocking

GetApp can return Cloudflare challenge pages to ordinary HTTP clients.

The Actor therefore uses:

- residential browser sessions;
- a realistic browser locale and headers;
- low sequential concurrency;
- blocked analytics, fonts, and media requests where safe;
- challenge and invalid-response detection;
- bounded proxy-session rotation;
- no output for empty challenge pages.

If every requested route fails and no product is extracted, the run exits non-zero rather than reporting false success.

### Tips for accurate results

- Start with exact product URLs when you already know the competitors.
- Keep the first category run small.
- Use canonical GetApp URLs rather than redirect or tracking links.
- Schedule snapshots at a cadence appropriate to your monitoring goal.
- Compare products by stable `url`, not by title alone.
- Treat missing pricing as source availability, not automatically as a zero price.
- Store `scrapedAt` when building historical comparisons.

### Scheduling a GetApp monitor

Use Apify Schedules to repeat a saved Actor task daily, weekly, or monthly.

A useful monitor flow is:

1. save exact competitor product URLs;
2. run weekly;
3. export or webhook the dataset;
4. compare the latest rows by canonical URL;
5. alert on plan, rating, or integration changes.

For category monitoring, keep `maxItems` stable so snapshots remain comparable.

### Integrations

#### Google Sheets

Send each run's dataset to a sheet for buyer research or a lightweight software catalog.

#### Make

Trigger the Actor, iterate over product rows, and update a database or send alerts.

#### Zapier

Run a saved task from a workflow and pass new competitor facts to your team tools.

#### Webhooks

Notify your pipeline when a run succeeds or fails, then download the dataset through its API URL.

#### Cloud storage and databases

Export JSON or CSV to your preferred warehouse, object store, or ETL pipeline.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/getapp-software-scraper').call({
  startUrls: [{ url: 'https://www.getapp.com/collaboration-software/a/slack/' }],
  maxItems: 1,
  proxyCountryCode: 'US'
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/getapp-software-scraper').call(run_input={
    'startUrls': [
        {'url': 'https://www.getapp.com/collaboration-software/a/slack/'}
    ],
    'maxItems': 1,
    'proxyCountryCode': 'US',
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~getapp-software-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.getapp.com/collaboration-software/a/slack/"}],
    "maxItems": 1,
    "proxyCountryCode": "US"
  }'
```

The run response contains links to status, logs, and storage.

### Use GetApp Software Scraper with MCP

Connect Apify Actors to compatible AI clients through [Apify MCP](https://mcp.apify.com/?tools=automation-lab/getapp-software-scraper).

#### Claude Code

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

Example prompt:

> Extract Slack and Asana from GetApp, then compare pricing, ratings, review counts, and integrations.

#### Claude Desktop

Add the following to the Claude Desktop MCP configuration:

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

#### Cursor

Open **Settings → Tools & Integrations → MCP**, add a remote server, and use the same `mcpServers` JSON and URL above.

#### VS Code

Open the MCP server settings for your AI extension, add an HTTP server named `apify`, and use:

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

Example prompt:

> Build a structured software shortlist from this GetApp category and summarize the top five by rating.

### Data quality notes

Ratings and review counts come from public structured page data when available.

Pricing plans are extracted from rendered public pricing sections and embedded page state.

Integration and feature arrays can be large because GetApp publishes extensive product catalogs.

Descriptions, prices, and product availability are controlled by GetApp and software vendors.

Always validate critical procurement decisions against the current source page.

### Is it legal to scrape GetApp?

This Actor extracts publicly accessible product information.

You are responsible for your use of the data and for complying with applicable laws, GetApp's terms, intellectual-property rights, privacy obligations, and contractual restrictions.

Do not use the Actor to collect restricted data, overload the source, or make decisions that require independent verification without reviewing the original source.

The Actor does not require a GetApp login and does not bypass private account controls.

### Troubleshooting

#### Why did my run fail with no products?

The input may be an unsupported URL, a discovery page may expose no product links, or all bounded browser sessions may have received a challenge. Verify the URL in a browser and retry later.

#### Why is a field missing?

GetApp does not publish every field for every product. Missing fields are omitted rather than guessed.

#### Why did a category return products I did not expect?

GetApp controls category recommendations and ranking. Use exact product URLs for a fixed competitor list.

#### Why are prices represented as text on some plans?

Plans such as enterprise packages may say “No pricing info” instead of publishing a number. The Actor preserves that state rather than treating it as zero.

### Frequently asked questions

#### Can I scrape several products in one run?

Yes. Add multiple product URLs or use a category/search page and set `maxItems`.

#### Does it extract individual GetApp reviews?

No. V1 extracts the overall rating and review count, not review text.

#### Does it need a GetApp account?

No. It targets public catalog pages.

#### Can I export to CSV or Excel?

Yes. Use the dataset export controls or API after the run.

#### Can I schedule it?

Yes. Save a task and attach an Apify Schedule.

#### Are duplicate products saved?

No. Products are deduplicated by canonical GetApp URL within a run.

### Related software research Actors

Use other automation-lab Actors when you need another source or workflow:

- [G2 Scraper](https://apify.com/automation-lab/g2-scraper)
- [G2 Reviews Scraper](https://apify.com/automation-lab/g2-reviews-scraper)
- [SaaSworthy Scraper](https://apify.com/automation-lab/saasworthy-scraper)
- [Crozdesk Scraper](https://apify.com/automation-lab/crozdesk-scraper)

Cross-source datasets should keep the source URL and capture time so records remain auditable.

### Support

For reproducible support requests, include:

- the GetApp URL;
- a link to the Apify run;
- the approximate run time;
- the expected field or product;
- whether the source page loaded in your browser.

Do not include private credentials or unrelated personal data.

### Start with a small run

Try the prefilled Slack product example with `maxItems: 1`.

Review the structured row, then add more exact product URLs or switch to a category workflow.

That small-first approach confirms source availability, output shape, and account pricing before a larger scheduled job.

# Actor input Schema

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

Public GetApp URLs to scrape. Category and search pages are followed into product detail pages.

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

Stop after saving this many unique software product records across all start URLs.

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

Maximum category/search pagination depth. Product detail URLs always use one page.

## `proxyCountryCode` (type: `string`):

Two-letter country code used for GetApp browser sessions.

## `maxRetries` (type: `integer`):

How many times to rotate the residential proxy session after a blocked or invalid page response.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.getapp.com/collaboration-software/a/slack/"
    }
  ],
  "maxItems": 3,
  "maxPagesPerUrl": 2,
  "proxyCountryCode": "US",
  "maxRetries": 2
}
```

# 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.getapp.com/collaboration-software/a/slack/"
        }
    ],
    "maxItems": 3,
    "maxPagesPerUrl": 2,
    "proxyCountryCode": "US",
    "maxRetries": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/getapp-software-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.getapp.com/collaboration-software/a/slack/" }],
    "maxItems": 3,
    "maxPagesPerUrl": 2,
    "proxyCountryCode": "US",
    "maxRetries": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/getapp-software-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.getapp.com/collaboration-software/a/slack/"
    }
  ],
  "maxItems": 3,
  "maxPagesPerUrl": 2,
  "proxyCountryCode": "US",
  "maxRetries": 2
}' |
apify call automation-lab/getapp-software-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GetApp Software Scraper",
        "description": "Turn public GetApp product, category, and search pages into enriched software rows with pricing, ratings, features, integrations, and media.",
        "version": "0.1",
        "x-build-id": "1YwzIwvMZTH6BIq9G"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~getapp-software-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-getapp-software-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~getapp-software-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-getapp-software-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~getapp-software-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-getapp-software-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": "🔗 GetApp product, category, or search URLs",
                        "type": "array",
                        "description": "Public GetApp URLs to scrape. Category and search pages are followed into product detail 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": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique software product records across all start URLs.",
                        "default": 10
                    },
                    "maxPagesPerUrl": {
                        "title": "📄 Maximum discovery pages per URL",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum category/search pagination depth. Product detail URLs always use one page.",
                        "default": 3
                    },
                    "proxyCountryCode": {
                        "title": "Residential proxy country",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Two-letter country code used for GetApp browser sessions.",
                        "default": "US"
                    },
                    "maxRetries": {
                        "title": "Challenge retries",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many times to rotate the residential proxy session after a blocked or invalid page response.",
                        "default": 2
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
