# Stealth Website Scraper (`solutionssmart/stealth-website-scraper`) Actor

Extract text, links, metadata, HTML, markdown, and structured page data with HTTP-first crawling and stealth-aware browser fallback.

- **URL**: https://apify.com/solutionssmart/stealth-website-scraper.md
- **Developed by:** [Solutions Smart](https://apify.com/solutionssmart) (community)
- **Categories:** Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Stealth Website Scraper

Stealth Website Scraper extracts text, links, metadata, HTML, markdown, and structured page data from websites using a fast HTTP-first crawl with browser fallback when plain requests are not enough.

It is designed for production scraping and analysis workflows where cost, speed, and reliability all matter. The actor starts with lightweight HTTP crawling through `CheerioCrawler`, then falls back to a browser flow when the site blocks requests, returns thin content, or depends on JavaScript rendering.

### What does Stealth Website Scraper do?

Stealth Website Scraper enables you to extract data from websites with intelligent fallback handling. Whether you are dealing with server-rendered content or JavaScript-heavy pages, this actor adapts its approach to maximize success while minimizing costs.

Stealth Website Scraper can extract:

- Clean text content and markdown from web pages
- Page metadata such as title, description, and canonical URL
- Headings such as H1 and H2
- Internal and external links
- HTML source code
- HTTP status codes and content type information
- Crawl depth and crawl method information

### Why scrape websites?

Websites contain publicly available data that can support AI pipelines, market research, competitive analysis, and business intelligence.

- **AI and RAG pipelines**: Feed clean text content into machine learning models and retrieval-augmented generation systems.
- **Business intelligence**: Extract metadata, pricing, and product information from competitor websites.
- **Content extraction**: Build datasets for training, analysis, and enrichment workflows.
- **Testing and QA**: Verify site rendering across different network conditions and browser types.
- **Market research**: Gather structured data from public websites at scale.
- **Fingerprint testing**: Compare stealth browser behavior against standard browser automation.

### How to scrape websites with Stealth Website Scraper

1. Click **Try for free** to open the actor.
2. Enter one or more **Start URLs**.
3. Configure optional settings:
   - **Max Pages**: Limit the number of pages to crawl.
   - **Max Depth**: Control how deep internal link crawling goes.
   - **Crawling Mode**: Choose between `http-first` and `browser-only`.
   - **Stealth Browser**: Select `cloak` to attempt CloakBrowser, or `playwright` for standard Playwright.
   - **Extraction Mode**: Choose what data to extract such as `all`, `text`, `markdown`, `html`, or `links`.
4. Click **Run**.
5. When the run completes, preview or download your data from the **Dataset** tab.

### How much will it cost to scrape websites?

Apify gives you $5 in free usage credits every month on the [Apify Free plan](https://apify.com/pricing). Since HTTP scraping is much cheaper than browser automation, you can extract many pages for low cost by relying on the HTTP-first strategy.

The Stealth Website Scraper uses HTTP requests first whenever possible. This means:

- Lower compute costs
- Faster execution
- Higher throughput
- Less browser overhead

Browser fallback only engages when necessary, keeping costs down while maintaining reliability.

For regular large-scale scraping, review current [Apify pricing](https://apify.com/pricing) and set `maxPages`, `maxDepth`, and concurrency to match your budget.

### Results

Each processed page produces one clean dataset item.

#### Example output

```json
{
  "url": "https://example.com",
  "loadedUrl": "https://example.com/",
  "domain": "example.com",
  "title": "Example Domain",
  "metaDescription": "A reserved-use domain in DNS",
  "canonicalUrl": "https://example.com/",
  "h1": ["Example Domain"],
  "h2": ["More information"],
  "text": "Example Domain This domain is for use in illustrative examples in documents...",
  "markdown": "## Example Domain\n\nThis domain is for use in illustrative examples in documents...",
  "html": "<!doctype html>\n<html>\n<head>...</head>...",
  "links": ["https://example.com/more-info", "https://example.com/about"],
  "externalLinks": ["https://www.iana.org/"],
  "statusCode": 200,
  "contentType": "text/html; charset=UTF-8",
  "depth": 0,
  "crawlMethod": "http",
  "fallbackUsed": false,
  "fallbackReason": "",
  "timestamp": "2026-05-17T21:00:00.000Z"
}
````

The actor also stores a final summary in the key-value store under `OUTPUT`:

```json
{
  "pagesScraped": 25,
  "httpPages": 22,
  "browserPages": 3,
  "cloakPages": 0,
  "failedPages": 0,
  "fallbacks": 3,
  "uniqueUrlsQueued": 27,
  "startedAt": "2026-05-17T21:00:00.000Z",
  "finishedAt": "2026-05-17T21:05:30.000Z",
  "durationSeconds": 330
}
```

### HTTP-first vs. browser mode

#### HTTP-first mode

The actor starts with lightweight HTTP requests using `CheerioCrawler`. This is the fastest and cheapest approach.

**Browser fallback triggers when:**

- The site returns `403`, `429`, or `503`
- The HTTP response body is empty or below `minTextLengthForSuccess`
- The page appears JavaScript-heavy
- Text extraction returns minimal content

#### Browser-only mode

Skip HTTP entirely and crawl exclusively with a browser. Useful for:

- JavaScript-heavy single-page applications
- Sites with stronger bot protection
- Pages requiring browser rendering

#### Stealth browser options

- **`cloak`**: Attempts [CloakBrowser](https://github.com/CloakHQ/CloakBrowser), a fingerprint-aware Chromium fork with source-level stealth patches. Falls back to standard Playwright if unavailable.
- **`playwright`**: Uses standard Playwright Chromium.

### Input parameters

#### Essential parameters

- **`startUrls`**: Array of URLs or objects with a `url` property. Required.
- **`maxPages`**: Maximum pages to scrape. Default: `100`.
- **`maxDepth`**: Maximum link depth for crawling. Default: `2`.
- **`crawlingMode`**: `http-first` or `browser-only`. Default: `http-first`.

#### Crawling options

- **`scrapeInternalLinks`**: Enable internal link crawling. Default: `true`.
- **`sameDomainOnly`**: Limit crawling to the start domain. Default: `true`.
- **`maxConcurrency`**: Concurrent request limit. Default: `5`.
- **`requestTimeoutSecs`**: Request timeout in seconds. Default: `30`.

#### Extraction options

- **`extractionMode`**: `all`, `text`, `markdown`, `html`, or `links`. Default: `all`.
- **`includeHtml`**: Include full HTML source. Default: `false`.
- **`includeLinks`**: Extract internal links. Default: `true`.
- **`includeExternalLinks`**: Extract external links. Default: `false`.

#### Browser options

- **`stealthBrowser`**: `cloak` or `playwright`. Default: `cloak`.
- **`waitUntil`**: `domcontentloaded`, `load`, or `networkidle`. Default: `domcontentloaded`.
- **`blockResources`**: Block images, fonts, media, and stylesheets to speed up rendering. Default: `true`.
- **`fallbackOnStatusCodes`**: Status codes that trigger browser fallback. Default: `[403, 429, 503]`.
- **`minTextLengthForSuccess`**: Minimum text length to avoid fallback. Default: `300`.

#### Proxy and headers

- **`proxyConfiguration`**: Proxy setup, including Apify Proxy.
- **`customUserAgent`**: Custom User-Agent header.

#### Example input

```json
{
  "startUrls": [
    { "url": "https://example.com" },
    "https://example.org/docs"
  ],
  "maxPages": 50,
  "maxDepth": 2,
  "sameDomainOnly": true,
  "scrapeInternalLinks": true,
  "extractionMode": "all",
  "crawlingMode": "http-first",
  "stealthBrowser": "cloak",
  "fallbackOnStatusCodes": [403, 429, 503],
  "minTextLengthForSuccess": 300,
  "waitUntil": "domcontentloaded",
  "blockResources": true,
  "includeHtml": false,
  "includeLinks": true,
  "includeExternalLinks": false,
  "maxConcurrency": 5,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### Tips for scraping websites

- **Start with HTTP mode**: Most websites serve useful HTML on initial request. HTTP-first saves money and runs faster.
- **Set appropriate depth limits**: Use `maxPages` and `maxDepth` to control crawl scope and stay within budget.
- **Use domain filtering**: Enable `sameDomainOnly` to prevent crawling into unrelated domains.
- **Adjust timeout settings**: Increase `requestTimeoutSecs` for slow or distant servers.
- **Enable resource blocking**: Keep `blockResources` set to `true` to skip heavy browser resources.
- **Monitor fallback rates**: Check the run summary to see how many pages needed browser fallback.
- **Test stealth options**: Use `stealthBrowser: "cloak"` if standard Playwright gets blocked.
- **Respect robots.txt**: Review website policies before scraping.

### Limitations

- Browser mode is more expensive than HTTP mode.
- Some websites require authentication, session warmup, or custom logic.
- Very aggressive protection systems may still throttle or block requests.
- CloakBrowser requires binary download at runtime if not preinstalled.
- External links can be extracted, but crawl expansion stays focused on start domains by default.

### Is it legal to scrape websites?

Scraping is legal in many jurisdictions, but you still need to follow applicable laws and website policies.

- **Respect robots.txt**: Check the website's `robots.txt` file and follow its rules where appropriate.
- **Review Terms of Service**: Some sites explicitly prohibit scraping in their terms.
- **Protect personal data**: Personal data may be protected by GDPR and similar laws. Only scrape it when you have a lawful basis.
- **Do not overload servers**: Use appropriate concurrency and crawl limits.
- **Respect copyright**: Do not republish copyrighted content without permission.

If you are unsure whether scraping a specific website is legal for your use case, consult a lawyer. For more information, read [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

# Actor input Schema

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

One or more URLs to scrape. Supports strings and request objects.

## `maxPages` (type: `integer`):

Maximum number of pages to process across the crawl.

## `maxDepth` (type: `integer`):

Maximum crawl depth from the start URLs.

## `sameDomainOnly` (type: `boolean`):

Restrict crawling to the same root domain as each start URL.

## `scrapeInternalLinks` (type: `boolean`):

Follow internal links discovered on scraped pages.

## `extractionMode` (type: `string`):

Choose the primary content extraction output.

## `crawlingMode` (type: `string`):

Choose HTTP-first crawling or full browser-only crawling.

## `stealthBrowser` (type: `string`):

Playwright is the default browser engine. CloakBrowser is attempted when selected.

## `fallbackOnStatusCodes` (type: `array`):

Trigger browser fallback when these HTTP response codes appear.

## `minTextLengthForSuccess` (type: `integer`):

Trigger browser fallback when extracted text is shorter than this threshold.

## `waitUntil` (type: `string`):

Navigation readiness state for browser scraping.

## `blockResources` (type: `boolean`):

Abort images, fonts, media, and stylesheets in browser mode to reduce cost.

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

Include the page HTML in the dataset output.

## `includeLinks` (type: `boolean`):

Include normalized internal links in output.

## `includeExternalLinks` (type: `boolean`):

Include normalized external links in output.

## `maxConcurrency` (type: `integer`):

Maximum parallel requests or pages.

## `requestTimeoutSecs` (type: `integer`):

Timeout for HTTP requests and browser navigation.

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

Apify proxy configuration.

## `customUserAgent` (type: `string`):

Optional user agent applied to HTTP requests and browser contexts.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ],
  "maxPages": 100,
  "maxDepth": 2,
  "sameDomainOnly": true,
  "scrapeInternalLinks": true,
  "extractionMode": "all",
  "crawlingMode": "http-first",
  "stealthBrowser": "cloak",
  "fallbackOnStatusCodes": [
    403,
    429,
    503
  ],
  "minTextLengthForSuccess": 300,
  "waitUntil": "domcontentloaded",
  "blockResources": true,
  "includeHtml": false,
  "includeLinks": true,
  "includeExternalLinks": false,
  "maxConcurrency": 5,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

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

Scraped page records stored in the default dataset, one item per processed page.

## `summary` (type: `string`):

Final run summary stored under the OUTPUT record in the default key-value store.

# 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://example.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solutionssmart/stealth-website-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://example.com" }] }

# Run the Actor and wait for it to finish
run = client.actor("solutionssmart/stealth-website-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://example.com"
    }
  ]
}' |
apify call solutionssmart/stealth-website-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Stealth Website Scraper",
        "description": "Extract text, links, metadata, HTML, markdown, and structured page data with HTTP-first crawling and stealth-aware browser fallback.",
        "version": "0.1",
        "x-build-id": "AtczkowNlCWfsPENd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solutionssmart~stealth-website-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solutionssmart-stealth-website-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/solutionssmart~stealth-website-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solutionssmart-stealth-website-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/solutionssmart~stealth-website-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solutionssmart-stealth-website-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": "Start URLs",
                        "type": "array",
                        "description": "One or more URLs to scrape. Supports strings and request objects.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxPages": {
                        "title": "Max pages",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of pages to process across the crawl.",
                        "default": 100
                    },
                    "maxDepth": {
                        "title": "Max depth",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum crawl depth from the start URLs.",
                        "default": 2
                    },
                    "sameDomainOnly": {
                        "title": "Same domain only",
                        "type": "boolean",
                        "description": "Restrict crawling to the same root domain as each start URL.",
                        "default": true
                    },
                    "scrapeInternalLinks": {
                        "title": "Crawl internal links",
                        "type": "boolean",
                        "description": "Follow internal links discovered on scraped pages.",
                        "default": true
                    },
                    "extractionMode": {
                        "title": "Extraction mode",
                        "enum": [
                            "text",
                            "markdown",
                            "html",
                            "links",
                            "all"
                        ],
                        "type": "string",
                        "description": "Choose the primary content extraction output.",
                        "default": "all"
                    },
                    "crawlingMode": {
                        "title": "Crawling mode",
                        "enum": [
                            "http-first",
                            "browser-only"
                        ],
                        "type": "string",
                        "description": "Choose HTTP-first crawling or full browser-only crawling.",
                        "default": "http-first"
                    },
                    "stealthBrowser": {
                        "title": "Browser engine",
                        "enum": [
                            "playwright",
                            "cloak"
                        ],
                        "type": "string",
                        "description": "Playwright is the default browser engine. CloakBrowser is attempted when selected.",
                        "default": "cloak"
                    },
                    "fallbackOnStatusCodes": {
                        "title": "Fallback HTTP status codes",
                        "type": "array",
                        "description": "Trigger browser fallback when these HTTP response codes appear.",
                        "items": {
                            "type": "integer",
                            "minimum": 100,
                            "maximum": 599
                        },
                        "default": [
                            403,
                            429,
                            503
                        ]
                    },
                    "minTextLengthForSuccess": {
                        "title": "Min text length for success",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Trigger browser fallback when extracted text is shorter than this threshold.",
                        "default": 300
                    },
                    "waitUntil": {
                        "title": "Browser waitUntil",
                        "enum": [
                            "domcontentloaded",
                            "load",
                            "networkidle"
                        ],
                        "type": "string",
                        "description": "Navigation readiness state for browser scraping.",
                        "default": "domcontentloaded"
                    },
                    "blockResources": {
                        "title": "Block heavy browser resources",
                        "type": "boolean",
                        "description": "Abort images, fonts, media, and stylesheets in browser mode to reduce cost.",
                        "default": true
                    },
                    "includeHtml": {
                        "title": "Include HTML in output",
                        "type": "boolean",
                        "description": "Include the page HTML in the dataset output.",
                        "default": false
                    },
                    "includeLinks": {
                        "title": "Include internal links",
                        "type": "boolean",
                        "description": "Include normalized internal links in output.",
                        "default": true
                    },
                    "includeExternalLinks": {
                        "title": "Include external links",
                        "type": "boolean",
                        "description": "Include normalized external links in output.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum parallel requests or pages.",
                        "default": 5
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 5,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Timeout for HTTP requests and browser navigation.",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration."
                    },
                    "customUserAgent": {
                        "title": "Custom user agent",
                        "type": "string",
                        "description": "Optional user agent applied to HTTP requests and browser contexts."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
