# Selenium Cloud Runner (`sovanza.inc/selenium-cloud-runner`) Actor

Selenium Cloud Runner scrapes JavaScript-heavy websites using Selenium and headless Chrome. It extracts data with CSS or XPath rules, supports scrolling, popup handling, screenshots, proxies, retries, and structured dataset exports.

- **URL**: https://apify.com/sovanza.inc/selenium-cloud-runner.md
- **Developed by:** [Sovanza](https://apify.com/sovanza.inc) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 scraped pages

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### 🌐 Selenium Cloud Runner – Dynamic Website Scraper & Browser Automation Tool

A powerful Selenium-based web scraper that renders JavaScript-heavy pages and extracts data using flexible CSS selectors or XPath rules.
This actor works as a universal browser scraping engine, allowing you to scrape almost any website without building a custom scraper from scratch.

---

### 🚀 Start Scraping Dynamic Websites

Extract data from modern web apps and SPA pages.

👉 Render JavaScript-heavy websites  
👉 Extract data using CSS or XPath  
👉 Handle scrolling and popups automatically  
👉 Export results to JSON, CSV, or Excel  

Click “Run” and start scraping instantly.

---

### 🧠 What This Tool Actually Solves

Most scraping tools fail on modern websites because:

Content loads dynamically via JavaScript  
HTML is not available in initial response  
Pages require scrolling or interaction  

This actor solves that by using:

Selenium + real browser rendering  
Dynamic DOM extraction  
Configurable waits and interactions  
Flexible extraction rules  

---

### ⚡ Key Features

Selenium web scraper (headless Chrome)  
Dynamic website scraping (SPA support)  
CSS selector and XPath extraction  
Infinite scroll handling  
Popup and modal handling  
Retry logic and error handling  
Screenshot capture support  
Proxy support for blocked sites  

---

### 🔄 How It Works

Open URL in headless browser  
Wait for page to load (selector-based)  
Handle popups and scrolling (optional)  
Extract data using rules  
Save structured results to dataset  

---

### 📊 Data You Can Extract

Using extraction rules, you can collect:

Text content  
HTML elements  
Attributes (links, images, etc.)  
Lists of elements (multiple matches)  

---

### 🎯 Real-World Use Cases

🌐 Dynamic Website Scraping  
Extract data from JavaScript-heavy sites and SPAs.

🛒 E-commerce Scraping  
Collect product listings, prices, and details.

📊 Content Monitoring  
Track changes in dashboards, feeds, or listings.

🔍 Search Result Extraction  
Scrape search pages with infinite scrolling.

🤖 Automation Workflows  
Integrate scraping into pipelines and APIs.

---

### 🛠️ How to Use

Add URLs to scrape  
Define extraction rules (CSS/XPath)  
Configure waits and scrolling  
Enable proxy if needed  
Run the actor  
Export or integrate results  

---

### 🛠️ How to Use Selenium Cloud Runner on Apify (aligned to this implementation)

At a high level:

1. Add one or more URLs in `urls`.
2. Set `waitForSelector` so the actor knows when the page is “ready”.
3. Define `extract` rules to collect fields using CSS or XPath.
4. (Optional) Enable `scroll` for infinite-scroll feeds and set `closeSelectors` for popups.
5. (Optional) Enable `takeScreenshot` (saves `SCREENSHOT_00001.png` etc. to the default key-value store).
6. (Optional) Enable `proxyConfiguration` for blocked sites (residential proxy recommended).
7. Run the actor and export results from the default Dataset (JSON/CSV/Excel) or fetch via API.

#### Input example

Full schema: `INPUT_SCHEMA.json`. Example:

```json
{
  "urls": ["https://example.com/"],
  "waitForSelector": "h1",
  "waitTimeoutSecs": 25,
  "extract": [
    { "name": "title", "selector": "h1", "type": "text", "all": false },
    { "name": "links", "selector": "a", "type": "attr", "attr": "href", "all": true }
  ],
  "scroll": {
    "enabled": false,
    "maxRounds": 10,
    "scrollBy": 900,
    "pauseSecs": 1.0,
    "stopOnNoNewHeightRounds": 2
  },
  "closeSelectors": [],
  "maxRetries": 2,
  "retryDelaySecs": 3,
  "includeVisibleText": true,
  "includeHtml": false,
  "takeScreenshot": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
````

- **`urls`** (required): One or more URLs to open.
- **`waitForSelector`** (optional): CSS or XPath selector to wait for before extraction (default `body`).
- **`extract`** (optional): Extraction rules (CSS or XPath) that produce custom fields.
- **`scroll`** (optional): Infinite scroll behavior.
- **`closeSelectors`** (optional): CSS selectors to click to close popups/modals.
- **`maxRetries` / `retryDelaySecs`** (optional): Retry policy per URL.
- **`includeVisibleText`** (optional): Include page visible text (default `true`).
- **`includeHtml`** (optional): Include full HTML (default `false`).
- **`takeScreenshot`** (optional): Save screenshots to key-value store (default `false`).
- **`proxyConfiguration`** (optional): Apify proxy settings.

***

### ⚙️ Input Configuration

Required\
urls → One or more URLs

Key Options\
waitForSelector → Page readiness condition\
extract\[] → Data extraction rules\
scroll → Infinite scroll configuration\
closeSelectors → Popup handling\
maxRetries / retryDelaySecs → Retry logic\
includeVisibleText → Extract full text\
includeHtml → Include page HTML\
takeScreenshot → Save page screenshots\
proxyConfiguration → Use proxy

***

### 🧩 Example Extraction Rules

{
"extract": \[
{ "name": "title", "selector": "h1", "type": "text" },
{ "name": "links", "selector": "a", "type": "attr", "attr": "href", "all": true }
]
}

***

### 📦 Output

Each dataset item includes:

inputUrl\
finalUrl\
status (OK / ERROR)\
pageTitle\
extracted data (custom fields)\
visibleText (optional)\
html (optional)\
screenshotKey (optional)\
error (if failed)\
timestamp

#### Output example

Example dataset item (illustrative):

```json
{
  "inputUrl": "https://example.com/",
  "finalUrl": "https://example.com/",
  "status": "OK",
  "pageTitle": "Example Domain",
  "extracted": {
    "title": "Example Domain",
    "links": ["https://www.iana.org/domains/example"]
  },
  "visibleText": "Example Domain ...",
  "screenshotKey": null,
  "error": null,
  "timestamp": "2026-04-29T12:00:00Z"
}
```

Example error row:

```json
{
  "inputUrl": "https://example.com/",
  "finalUrl": "https://example.com/",
  "status": "ERROR",
  "pageTitle": null,
  "extracted": {},
  "error": "Navigation failed (Chrome error page). chrome_error_url:chrome-error://chromewebdata/",
  "timestamp": "2026-04-29T12:00:00Z"
}
```

***

### 🔐 Anti-Blocking & Best Practices

To improve success rate:

Use residential proxy\
Increase wait times\
Use correct selectors\
Limit request frequency

***

### FAQ

#### What is Selenium Cloud Runner used for?

It is a dynamic website scraper that extracts data from JavaScript-heavy pages using Selenium and browser automation.

#### When should I use Selenium instead of simple HTTP scraping?

Use Selenium when:

Content is loaded dynamically\
JavaScript rendering is required\
Pages need interaction (scrolling, clicks)

#### Can I scrape multiple pages in one run?

Yes. You can provide multiple URLs and process them in a single run.

#### What is the difference between CSS and XPath selectors?

Both are used to locate elements in the DOM:

CSS is simpler and faster\
XPath is more powerful for complex queries

#### Why am I getting empty results?

Possible reasons:

Incorrect selector\
Page not fully loaded\
Site blocking requests

#### Can I extract multiple elements at once?

Yes. Use "all": true in extraction rules to return lists.

#### Can I take screenshots of pages?

Yes. Enable takeScreenshot to save screenshots to the key-value store.

#### What formats can I export data in?

JSON, CSV, and Excel — or via the Apify platform API.

#### Is this suitable for large-scale scraping?

Yes, but you should configure proxies, retries, and concurrency properly.

#### Can I integrate this into automation workflows?

Yes. This actor is designed for pipelines, APIs, and scheduled jobs.

***

### 📈 Why Use This Tool?

Instead of building custom Selenium scripts, you get:

Ready-to-use browser scraper\
Flexible extraction system\
Scalable scraping workflows\
Structured data output

***

### 🚀 Get Started

Add your URLs and extraction rules to start scraping dynamic websites instantly.

# Actor input Schema

## `urls` (type: `array`):

One or more URLs to open in Selenium and extract data from (one per line).

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

How many times to retry a URL if navigation/extraction fails.

## `retryDelaySecs` (type: `number`):

Sleep between retries.

## `headless` (type: `boolean`):

Run Chrome in headless mode (recommended on Apify).

## `pageLoadTimeoutSecs` (type: `integer`):

Maximum time to wait for page navigation.

## `waitForSelector` (type: `string`):

Optional selector to wait for after navigation. If it starts with // or (.// it is treated as XPath; otherwise CSS.

## `waitTimeoutSecs` (type: `integer`):

Maximum time to wait for waitForSelector.

## `closeSelectors` (type: `array`):

CSS selectors to click (best-effort) to close popups/modals after page load.

## `scroll` (type: `object`):

Optional scrolling behavior for pages that load content dynamically.

## `extract` (type: `array`):

Flexible extraction config. Each rule uses CSS or XPath and extracts text/HTML/attributes.

## `includeHtml` (type: `boolean`):

If enabled, store full page HTML in the dataset item (can be large).

## `includeVisibleText` (type: `boolean`):

If enabled, store visible page text (body.innerText).

## `takeScreenshot` (type: `boolean`):

If enabled, takes a PNG screenshot and stores it in the default key-value store (key includes index).

## `saveCsvToKeyValueStore` (type: `boolean`):

If enabled, writes a CSV summary of dataset items to the default key-value store as OUTPUT.csv.

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

Apify proxy settings (recommended for tougher targets).

## Actor input object example

```json
{
  "urls": [
    "https://example.com/"
  ],
  "maxRetries": 2,
  "retryDelaySecs": 3,
  "headless": true,
  "pageLoadTimeoutSecs": 60,
  "waitForSelector": "body",
  "waitTimeoutSecs": 25,
  "closeSelectors": [],
  "scroll": {
    "enabled": false,
    "maxRounds": 10,
    "scrollBy": 900,
    "pauseSecs": 1,
    "stopOnNoNewHeightRounds": 2
  },
  "extract": [
    {
      "name": "title",
      "selector": "title",
      "type": "text",
      "all": false
    },
    {
      "name": "h1",
      "selector": "h1",
      "type": "text",
      "all": false
    }
  ],
  "includeHtml": false,
  "includeVisibleText": true,
  "takeScreenshot": false,
  "saveCsvToKeyValueStore": false
}
```

# Actor output Schema

## `results` (type: `string`):

Structured extraction results per URL in the default dataset.

## `csvExport` (type: `string`):

Combined CSV when saveCsvToKeyValueStore is enabled.

## `keyValueStore` (type: `string`):

All KV records including OUTPUT.csv and screenshot PNGs (SCREENSHOT\_\*.png).

# 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 = {
    "urls": [
        "https://example.com/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sovanza.inc/selenium-cloud-runner").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 = { "urls": ["https://example.com/"] }

# Run the Actor and wait for it to finish
run = client.actor("sovanza.inc/selenium-cloud-runner").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 '{
  "urls": [
    "https://example.com/"
  ]
}' |
apify call sovanza.inc/selenium-cloud-runner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sovanza.inc/selenium-cloud-runner",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Selenium Cloud Runner",
        "description": "Selenium Cloud Runner scrapes JavaScript-heavy websites using Selenium and headless Chrome. It extracts data with CSS or XPath rules, supports scrolling, popup handling, screenshots, proxies, retries, and structured dataset exports.",
        "version": "0.0",
        "x-build-id": "ncPq76yOPwtsETnyr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sovanza.inc~selenium-cloud-runner/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sovanza.inc-selenium-cloud-runner",
                "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/sovanza.inc~selenium-cloud-runner/runs": {
            "post": {
                "operationId": "runs-sync-sovanza.inc-selenium-cloud-runner",
                "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/sovanza.inc~selenium-cloud-runner/run-sync": {
            "post": {
                "operationId": "run-sync-sovanza.inc-selenium-cloud-runner",
                "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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more URLs to open in Selenium and extract data from (one per line).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRetries": {
                        "title": "Max retries per URL",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry a URL if navigation/extraction fails.",
                        "default": 2
                    },
                    "retryDelaySecs": {
                        "title": "Retry delay (seconds)",
                        "minimum": 0,
                        "maximum": 60,
                        "type": "number",
                        "description": "Sleep between retries.",
                        "default": 3
                    },
                    "headless": {
                        "title": "Headless mode",
                        "type": "boolean",
                        "description": "Run Chrome in headless mode (recommended on Apify).",
                        "default": true
                    },
                    "pageLoadTimeoutSecs": {
                        "title": "Page load timeout (seconds)",
                        "minimum": 5,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Maximum time to wait for page navigation.",
                        "default": 60
                    },
                    "waitForSelector": {
                        "title": "Wait for selector (CSS or XPath)",
                        "type": "string",
                        "description": "Optional selector to wait for after navigation. If it starts with // or (.// it is treated as XPath; otherwise CSS.",
                        "default": "body"
                    },
                    "waitTimeoutSecs": {
                        "title": "Wait timeout (seconds)",
                        "minimum": 1,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Maximum time to wait for waitForSelector.",
                        "default": 25
                    },
                    "closeSelectors": {
                        "title": "Close popups (CSS selectors)",
                        "type": "array",
                        "description": "CSS selectors to click (best-effort) to close popups/modals after page load.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "scroll": {
                        "title": "Scrolling / infinite scroll",
                        "type": "object",
                        "description": "Optional scrolling behavior for pages that load content dynamically.",
                        "default": {
                            "enabled": false,
                            "maxRounds": 10,
                            "scrollBy": 900,
                            "pauseSecs": 1,
                            "stopOnNoNewHeightRounds": 2
                        }
                    },
                    "extract": {
                        "title": "Extraction rules",
                        "type": "array",
                        "description": "Flexible extraction config. Each rule uses CSS or XPath and extracts text/HTML/attributes.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {
                                    "title": "Field name",
                                    "type": "string",
                                    "description": "Field name in output item.",
                                    "editor": "textfield"
                                },
                                "selector": {
                                    "title": "Selector (CSS or XPath)",
                                    "type": "string",
                                    "description": "CSS selector or XPath (starting with // or (.//).",
                                    "editor": "textfield"
                                },
                                "type": {
                                    "title": "Extract type",
                                    "type": "string",
                                    "description": "What to extract from the matched element(s).",
                                    "editor": "select",
                                    "enum": [
                                        "text",
                                        "html",
                                        "attr"
                                    ]
                                },
                                "attr": {
                                    "title": "Attribute name",
                                    "type": "string",
                                    "description": "Attribute name (required when type=attr).",
                                    "editor": "textfield"
                                },
                                "all": {
                                    "title": "Extract all matches",
                                    "type": "boolean",
                                    "description": "If true, extract all matches as list. If false, first match only.",
                                    "editor": "checkbox",
                                    "default": false
                                }
                            },
                            "required": [
                                "name",
                                "selector",
                                "type"
                            ]
                        },
                        "default": [
                            {
                                "name": "title",
                                "selector": "title",
                                "type": "text",
                                "all": false
                            },
                            {
                                "name": "h1",
                                "selector": "h1",
                                "type": "text",
                                "all": false
                            }
                        ]
                    },
                    "includeHtml": {
                        "title": "Include full HTML",
                        "type": "boolean",
                        "description": "If enabled, store full page HTML in the dataset item (can be large).",
                        "default": false
                    },
                    "includeVisibleText": {
                        "title": "Include visible text",
                        "type": "boolean",
                        "description": "If enabled, store visible page text (body.innerText).",
                        "default": true
                    },
                    "takeScreenshot": {
                        "title": "Take screenshot",
                        "type": "boolean",
                        "description": "If enabled, takes a PNG screenshot and stores it in the default key-value store (key includes index).",
                        "default": false
                    },
                    "saveCsvToKeyValueStore": {
                        "title": "Save CSV (key-value store)",
                        "type": "boolean",
                        "description": "If enabled, writes a CSV summary of dataset items to the default key-value store as OUTPUT.csv.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings (recommended for tougher targets)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```