# Web to Markdown API — HTML Scraper works with all sites (`imapp/web-markdown-api`) Actor

Convert any public URL to clean, token-efficient Markdown — purpose-built for RAG pipelines, LLM ingestion, and AI agents. Multi-layer bot evasion handles Cloudflare & JS SPAs. CSS selector filtering, metadata extraction, and token budget control included. Free trial, Pay-per-result from $0.0004.

- **URL**: https://apify.com/imapp/web-markdown-api.md
- **Developed by:** [INAPP](https://apify.com/imapp) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Web → Markdown API — URL to LLM-Ready Markdown

**$0.0004/result · Free 7-day Pro trial · No credit card**

Convert any public URL into clean, token-efficient Markdown — purpose-built for
AI agents, RAG pipelines, and LLM ingestion. Powered by Trafilatura with a
multi-layer bot evasion stack that handles Cloudflare and JS-heavy SPAs.

[![Try it on Apify](https://img.shields.io/badge/Apify-Try%20now-%2300B4D8)](https://apify.com/imapp/web-markdown-api)

---

### Quick Start

```bash
## Basic URL → Markdown
curl -X POST https://imapp--web-markdown-api.apify.actor/v1/markdown \
  -H "Content-Type: application/json" \
  -d '{"url": "https://en.wikipedia.org/wiki/Markdown"}'

## Get a free trial key (7-day Pro access)
curl -X POST https://imapp--web-markdown-api.apify.actor/v1/trial

## Convert raw HTML (skip the fetch step)
curl -X POST https://imapp--web-markdown-api.apify.actor/v1/html \
  -H "Content-Type: application/json" \
  -d '{"html": "<html><body><h1>Hello</h1><p>World</p></body></html>"}'

## Using your API key
curl -X POST https://imapp--web-markdown-api.apify.actor/v1/markdown \
  -H "Authorization: Bearer your_key" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com", "options": {"output_format": "text"}}'
````

***

### Features

| Feature | Description |
|---------|-------------|
| **Clean Markdown** | Navigation, sidebars, and ads stripped automatically |
| **Multi-format output** | `markdown`, `text` (plain), or `json` (structured) |
| **CSS selector filtering** | Extract specific elements (`article.main`, `#content`) |
| **Token budget control** | Set `max_length` to fit LLM context windows (100–1M chars) |
| **Metadata extraction** | Title, description, author, date, word count, language |
| **Bot evasion stack** | curl\_cffi TLS impersonation → httpx → Playwright browser |
| **Browser rendering** | Optional headless Chromium for JS-heavy SPAs |
| **Free trial** | 7-day Pro access, no credit card required |
| **Rate limiting** | Per-client RPS + monthly quota with tiered limits |

#### Bot Evasion Stack

The API automatically falls through three layers to get content:

```
Fetch attempt        ──► curl_cffi (Chrome TLS fingerprint)
                             │
                        success? ──► Return content
                             │ fail
                             ▼
                        httpx (plain HTTP)
                             │
                        success? ──► Return content
                             │ fail (use_browser=true)
                             ▼
                        Playwright (headless Chromium)
                             │
                        success? ──► Return content
```

- **Layer 1: curl\_cffi** — Impersonates Chrome 125 TLS fingerprint. Passes
  Cloudflare's first line of defense. Handles ~80% of sites.
- **Layer 2: httpx** — Plain HTTP fallback for simple sites.
- **Layer 3: Playwright** — Full browser rendering for JavaScript-heavy SPAs
  (React, Vue, Angular). Patches `navigator.webdriver`, WebGL, permissions,
  and plugins for stealth.

***

### Pricing

**Pay-per-result** — you only pay for successful conversions.

| Event | Price | What You Get |
|-------|-------|-------------|
| **API result** | **$0.0004** | Per successful URL → Markdown conversion (10K = $4) |
| **Actor start** | **$0.00005** | One-time per session (first 5 seconds waived) |

#### Tier Limits

| Tier | Calls/month | RPS | Example monthly cost at max usage |
|------|:-----------:|:---:|:---------------------------------:|
| **Free** | 10,000 | 5 | $0 (always) |
| **Starter** | 25,000 | 10 | ~$10 |
| **Pro** | 100,000 | 25 | ~$40 |
| **Enterprise** | 500,000 | 50 | ~$200 |

> Prices shown are base rates before Apify platform discounts (Bronze/Silver/Gold).

> **Apify user discounts:** Apify subscription tiers (Bronze/Silver/Gold) apply
> a discount to the per-result price automatically.

***

### Authentication

Pass your API key via one of two methods:

```bash
## Option A: Authorization header (recommended)
curl -H "Authorization: Bearer sk_pro_abc123" ...

## Option B: x-api-key header
curl -H "x-api-key: sk_pro_abc123" ...
```

**No key?** Unauthenticated requests are rate-limited to **5 RPS / 10K calls/mo**
(free tier). Get a **free 7-day Pro trial** at `POST /v1/trial` to unlock
25 RPS and 100K calls/mo.

#### Free Trial

```bash
curl -X POST https://imapp--web-markdown-api.apify.actor/v1/trial
```

```json
{
  "api_key": "trial_a1b2c3d4e5f6g7h8",
  "tier": "pro",
  "expires_in_days": 7,
  "usage_instructions": {
    "authorization": "Bearer trial_a1b2c3d4e5f6g7h8",
    "endpoints": ["POST /v1/markdown"],
    "note": "POST /v1/html also available for converting raw HTML",
    "docs": "/docs"
  }
}
```

**Trial limits:** 1 key per IP address · 1 request per 60 seconds.

***

### API Reference

All endpoints are versioned under `/v1`. Full interactive docs at
[`/docs`](https://imapp--web-markdown-api.apify.actor/docs) (Swagger UI)
or [`/redoc`](https://imapp--web-markdown-api.apify.actor/redoc).

#### `GET /health`

Health check for load-balancer probes. Unversioned — always accessible.

```bash
curl https://imapp--web-markdown-api.apify.actor/health
```

```json
{"status":"ok","service":"web-markdown-api","version":"0.1.0"}
```

#### `POST /v1/markdown`

Convert a public URL to clean Markdown, plain text, or structured JSON.

##### Request Body

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `url` | string | *required* | The URL to convert (http/https) |
| `options.output_format` | string | `"markdown"` | `markdown`, `text`, or `json` |
| `options.css_selector` | string | `null` | CSS selector for a specific element |
| `options.max_length` | int | `null` | Max output characters (100–1,000,000) |
| `options.include_links` | bool | `true` | Preserve hyperlinks in output |
| `options.include_images` | bool | `false` | Include image references |
| `options.exclude_navigation` | bool | `true` | Strip nav/sidebar/footer |
| `options.use_browser` | bool | `false` | Enable headless Chromium for JS-rendered pages |

##### Example: Markdown output

```bash
curl -X POST https://imapp--web-markdown-api.apify.actor/v1/markdown \
  -H "Authorization: Bearer your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://en.wikipedia.org/wiki/Markdown",
    "options": {
      "output_format": "markdown",
      "max_length": 5000,
      "include_links": true,
      "exclude_navigation": true
    }
  }'
```

```json
{
  "success": true,
  "url": "https://en.wikipedia.org/wiki/Markdown",
  "markdown": "# Markdown\n\n**Markdown** is a lightweight markup language...",
  "metadata": {
    "title": "Markdown - Wikipedia",
    "description": "Lightweight markup language for plain text formatting",
    "word_count": 1450,
    "char_count": 8900,
    "image_count": 3,
    "link_count": 45,
    "language": "en"
  },
  "output_format": "markdown",
  "source": "trafilatura"
}
```

##### Example: Plain text output

```bash
curl -X POST https://imapp--web-markdown-api.apify.actor/v1/markdown \
  -H "Authorization: Bearer your_key" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com", "options": {"output_format": "text"}}'
```

```json
{
  "success": true,
  "url": "https://example.com",
  "text": "Example Domain\n\nThis domain is for use in illustrative examples...",
  "metadata": {"word_count": 17},
  "output_format": "text",
  "source": "trafilatura"
}
```

##### Example: Browser rendering for JS-heavy pages

```bash
curl -X POST https://imapp--web-markdown-api.apify.actor/v1/markdown \
  -H "Authorization: Bearer your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://react.dev/reference/react/hooks",
    "options": {
      "output_format": "markdown",
      "use_browser": true,
      "max_length": 2000
    }
  }'
```

> **Note:** `use_browser: true` enables headless Chromium via Playwright.
> This is slower (3-10s per page) but can handle JavaScript-rendered SPAs
> that HTTP-only fetchers can't parse.

#### `POST /v1/html`

Convert raw HTML directly to Markdown — no fetch step. Useful when you
already have the HTML content and want to skip the network request.

Same options as `/v1/markdown` (minus the `url` field).

```bash
curl -X POST https://imapp--web-markdown-api.apify.actor/v1/html \
  -H "Authorization: Bearer your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "html": "<html><body><h1>Hello</h1><p>This is <strong>bold</strong> text.</p></body></html>",
    "options": {"output_format": "markdown"}
  }'
```

```json
{
  "success": true,
  "url": "",
  "markdown": "# Hello\n\nThis is **bold** text.",
  "metadata": {"word_count": 5},
  "output_format": "markdown",
  "source": "trafilatura"
}
```

#### `POST /v1/trial`

Get a free 7-day Pro trial key. See [Authentication](#authentication) above
for the full response format and limits.

#### `GET /v1/usage`

Rate-limit usage statistics — for monitoring and debugging.

```bash
curl https://imapp--web-markdown-api.apify.actor/v1/usage \
  -H "Authorization: Bearer your_key"
```

```json
{
  "active_clients": 12,
  "total_monthly_calls": 3421,
  "by_tier": {
    "free": {"clients": 8, "calls_this_month": 1200},
    "pro": {"clients": 4, "calls_this_month": 2221}
  }
}
```

#### Error Responses

| Status | Meaning |
|--------|---------|
| 400 | Bad request (invalid parameters) |
| 404 | URL returned HTTP 404 |
| 422 | Validation error (invalid URL format, empty HTML) |
| 429 | Rate limit exceeded (RPS or monthly quota) |
| 502 | Failed to fetch, render, or convert the URL |

Rate-limited responses include retry information:

```json
{
  "detail": "RPS limit exceeded",
  "retry_after_seconds": 0.85,
  "upgrade_url": "https://console.apify.com/actors/imapp~web-markdown-api",
  "tier": "free"
}
```

All responses include rate-limit headers:

```text
X-RateLimit-Limit-RPS: 5
X-RateLimit-Remaining-RPS: 4
X-RateLimit-Limit-Monthly: 10000
X-RateLimit-Remaining-Monthly: 9997
X-Tier: free
```

***

### Use Cases

| Use Case | How It Helps |
|----------|-------------|
| **RAG Pipelines** | Ingest web content into vector databases (Pinecone, Weaviate, Qdrant) for semantic search |
| **AI Agents** | Provide clean, token-efficient context for Claude, GPT, Gemini reasoning |
| **Content Analysis** | Extract and analyze article text, sentiment, or topics at scale |
| **Documentation Ingestion** | Convert docs to Markdown for LLM fine-tuning or RAG |
| **Data Collection** | Build structured datasets from web sources without browser overhead |
| **Competitor Monitoring** | Track pricing, features, and content changes on competitor sites |

***

### Rate Limits

Each tier has a **requests-per-second** (RPS) cap and a **monthly quota**.
See the [Pricing section](#pricing) for tier-specific limits.

- Free tier: 5 RPS, 10K calls/month
- Pro trial: 25 RPS, 100K calls/month (7 days)
- Paid keys: Configured per customer

When you exceed either limit, all endpoints return `HTTP 429` with a
`retry_after_seconds` field and a link to upgrade.

***

### Environment Variables

| Variable | Default | Description |
|----------|---------|-------------|
| `LOG_LEVEL` | `info` | Log verbosity (`debug`, `info`, `warning`, `error`) |
| `DEFAULT_RPS` | `5` | Free tier requests/second limit |
| `DEFAULT_MONTHLY_CALLS` | `10000` | Free tier monthly call limit |
| `PRO_RPS` | `25` | Pro tier requests/second |
| `PRO_MONTHLY_CALLS` | `100000` | Pro tier monthly calls |
| `HTTP_TIMEOUT` | `30` | HTTP fetch timeout in seconds |
| `MAX_RESPONSE_SIZE` | `5242880` | Max response size in bytes (5 MB) |
| `PRIMARY_FETCHER` | `curl_cffi` | Primary HTTP client (`curl_cffi` or `httpx`) |
| `USER_AGENT` | — | Custom User-Agent override (disables rotation) |
| `API_KEYS_JSON` | `{}` | JSON mapping of API keys to tiers (set as **Secret**) |
| `ENABLE_PROXY` | auto | Enable Apify proxy (`1`, `true`, or auto-detect) |
| `PROXY_GROUPS` | `RESIDENTIAL` | Apify proxy group |
| `TRIAL_DURATION_DAYS` | `7` | Trial key validity period |

> **Secrets:** `API_KEYS_JSON` should be set as a **Secret** in the
> Apify Console (Settings → Secrets), not as a regular environment variable.

***

***

### Supported Sites

| Type | Quality | Notes |
|------|---------|-------|
| Blog posts, news, docs | ⭐ Excellent | Trafilatura excels at article extraction |
| Static HTML sites | ⭐ Excellent | Fast, reliable, low latency |
| JavaScript SPAs (React, Vue) | ⭐ Good | Enable `use_browser: true` for JS rendering |
| Cloudflare-protected sites | ⭐ Good | TLS impersonation handles most challenges |
| PDFs, images, binaries | ❌ Not supported | Return HTTP 502 with error detail |

***

### About

Built by [imapp](https://apify.com/imapp). Part of the IM App suite of
developer APIs on the Apify platform.

**Questions?** [Open an issue](https://github.com/imapp/web-markdown-api/issues)
or reach out via the Apify Console.

# Actor input Schema

## `logLevel` (type: `string`):

Verbosity of server logs.

## `httpTimeout` (type: `integer`):

Timeout for fetching web pages.

## `defaultRps` (type: `integer`):

Requests per second limit for free tier users.

## `defaultMonthlyCalls` (type: `integer`):

Monthly call limit for free tier users.

## `apiKeysJson` (type: `string`):

JSON mapping of API keys to tier names for paid access.

## Actor input object example

```json
{
  "logLevel": "info",
  "httpTimeout": 30,
  "defaultRps": 5,
  "defaultMonthlyCalls": 10000,
  "apiKeysJson": "{}"
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("imapp/web-markdown-api").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("imapp/web-markdown-api").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 '{}' |
apify call imapp/web-markdown-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=imapp/web-markdown-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Web to Markdown API — HTML Scraper works with all sites",
        "description": "Convert any public URL to clean, token-efficient Markdown — purpose-built for RAG pipelines, LLM ingestion, and AI agents. Multi-layer bot evasion handles Cloudflare & JS SPAs. CSS selector filtering, metadata extraction, and token budget control included. Free trial, Pay-per-result from $0.0004.",
        "version": "0.1",
        "x-build-id": "4S6UV97OTfhOmnCIW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/imapp~web-markdown-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-imapp-web-markdown-api",
                "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/imapp~web-markdown-api/runs": {
            "post": {
                "operationId": "runs-sync-imapp-web-markdown-api",
                "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/imapp~web-markdown-api/run-sync": {
            "post": {
                "operationId": "run-sync-imapp-web-markdown-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "logLevel": {
                        "title": "Log Level",
                        "enum": [
                            "debug",
                            "info",
                            "warning",
                            "error"
                        ],
                        "type": "string",
                        "description": "Verbosity of server logs.",
                        "default": "info"
                    },
                    "httpTimeout": {
                        "title": "HTTP Request Timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Timeout for fetching web pages.",
                        "default": 30
                    },
                    "defaultRps": {
                        "title": "Free Tier RPS Limit",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Requests per second limit for free tier users.",
                        "default": 5
                    },
                    "defaultMonthlyCalls": {
                        "title": "Free Tier Monthly Limit",
                        "minimum": 100,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Monthly call limit for free tier users.",
                        "default": 10000
                    },
                    "apiKeysJson": {
                        "title": "API Key Tiers (JSON)",
                        "type": "string",
                        "description": "JSON mapping of API keys to tier names for paid access.",
                        "default": "{}"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
