# Article-to-Markdown Converter 📝 (`perryay/article-to-markdown-converter`) Actor

Extract article content from any URL and convert to clean Markdown. Strips navigation, sidebars, and ads using readability algorithms. Returns title, author, date, excerpt, word count, reading time. Batch up to 10 URLs.

- **URL**: https://apify.com/perryay/article-to-markdown-converter.md
- **Developed by:** [Perry AY](https://apify.com/perryay) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.005 / actor start

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Article-to-Markdown Converter 📝 — Web Content to Clean Markdown

**Extract the main article content from any webpage and convert it to clean, well-formatted Markdown — stripping navigation, sidebars, ads, and clutter using readability algorithms.**

---

### What does it do?

Every article on the web is surrounded by navigation menus, sidebar widgets, related-post links, advertisement blocks, cookie notices, and footer content. When you just want the article — the text, headings, images, and structure — these distractions make manual copying tedious and automated extraction unreliable.

**Article-to-Markdown Converter** solves this by fetching any article URL, running it through readability algorithms that identify and extract the main content, and converting the clean HTML to beautifully formatted Markdown. It automatically strips away everything that isn't the article, returning only what matters.

The actor goes beyond simple content extraction. It also harvests metadata from Open Graph tags, Twitter cards, JSON-LD structured data, and HTML meta tags — giving you the article's title, author, publication date, excerpt, word count, and estimated reading time alongside the full Markdown output.

For teams managing content workflows, the batch mode processes up to 10 article URLs in a single run, making it ideal for content migration, RSS feed enrichment, or building training datasets for AI models.

---

### Who is it for?

| Persona | What they use it for |
|---------|---------------------|
| **Content Writer** | Republishing articles across platforms — extract from a source URL and reformat for a new CMS |
| **Data Scientist** | Building text datasets for NLP training — clean article extraction without HTML boilerplate |
| **Developer** | Creating offline reading experiences — fetch and cache clean Markdown versions of documentation |
| **Researcher** | Gathering article content for literature reviews and citation management |
| **AI/ML Engineer** | Preprocessing web content for LLM training data — structured output with extracted metadata |
| **Technical Writer** | Migrating documentation between platforms — HTML to Markdown with preserved formatting |
| **SEO Specialist** | Analyzing competitor content structure and extracting article metadata for competitive analysis |

---

### Why use this?

- **Readability-first extraction, not regex scraping** — Uses the readability-lxml library (the same algorithm powering Firefox Reader View and Pocket) to identify the main content block. It understands article structure, not just HTML tags.

- **Strips everything non-essential** — No navigation, no sidebars, no related-posts widgets, no cookie banners, no footer links, no comment sections. Just the article content.

- **Metadata extraction from multiple sources** — Pulls title, author, and date from Open Graph tags (`og:title`, `article:published_time`), Twitter cards, JSON-LD structured data, HTML meta tags, and `<time>` elements. If data exists anywhere in the page head, the actor finds it.

- **Clean Markdown output with html2text** — Converts the extracted HTML to well-structured Markdown. Preserves headings, links, images, bold/italic, code blocks, lists, and blockquotes. No raw HTML leaking into the output.

- **Reading time estimation** — Automatically calculates reading time at 200 words per minute, a standard metric used by Medium and other publishing platforms.

- **Word count and content length metrics** — Know exactly how long each article is before you read or process it. Useful for content planning and dataset quality checks.

- **Batch processing for content workflows** — Submit up to 10 article URLs and get a consolidated dataset. Perfect for migrating a blog, enriching an RSS feed, or building a content archive.

- **No API key required** — Just point it at any public article URL. No signups, no rate limits, no third-party dependencies for the core extraction.

---

### Features

#### 1. Readability-Based Content Extraction
Uses the `readability-lxml` library, the same algorithm behind Firefox Reader View. It analyzes the HTML structure to find the main content block — looking at text density, paragraph distribution, and semantic HTML5 elements like `<article>` and `<main>`. If readability-lxml is not available, it falls back to a container-based extraction that looks for common content div IDs and classes (`content`, `post`, `article`, `entry`, `main`).

#### 2. Multi-Source Metadata Extraction
Metadata is gathered from every available source in priority order:
- **Title**: `og:title` → `twitter:title` → `<title>` tag
- **Author**: `meta name="author"` → JSON-LD `author.name`
- **Date**: `article:published_time` → `meta name="date"` → `<time datetime="">`
- **Excerpt**: `og:description` → `meta name="description"` (truncated to 300 chars)

#### 3. HTML to Markdown Conversion
The extracted HTML is converted to Markdown using `html2text` with strict settings:
- No line wrapping (respects original paragraph breaks)
- Inline link format for readability
- Unicode-aware (preserves special characters and non-Latin scripts)
- Emphasis preserved (bold, italic, code)
- Images and links converted to Markdown syntax
- Internal links (`#fragment`) skipped

#### 4. Structured Output with Metrics
Every extraction returns a comprehensive data object including:
- Full URL and domain
- Article title, author, and publication date
- Excerpt/description
- Word count (accurate, not estimated)
- Reading time in minutes (rounded to nearest minute)
- Content length in characters
- Image count within the article
- Extraction method used
- HTTP status and fetch time

#### 5. Batch Mode (Up to 10 URLs)
Submit multiple article URLs in a single run for batch processing. Each article is fetched and extracted independently. Failed URLs are reported individually without affecting successful extractions. All results are pushed to the same dataset.

#### 6. Configurable Output Fields
Control how much data is returned per article:
- `includeMarkdown: true` (default) — Full Markdown content in output
- `includeHtml: false` (default) — No raw HTML in output (saves space)
- Both can be disabled to return only metadata and metrics

#### 7. Graceful Error Handling
- Automatic retries with backoff for transient network errors
- Timeout handling (60-second read timeout for large articles)
- Content size limits (5MB max HTML)
- Minimum content threshold (100 chars minimum to be considered valid)
- Partial batch results preserved on individual failures

---

### Input Parameters

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `url` | string | Yes* | — | Single article URL to extract content from |
| `batchMode` | boolean | No | false | Enable batch processing for multiple URLs |
| `batchData` | array | No* | — | Array of objects with `url` fields for batch mode (max 10 items) |
| `includeMarkdown` | boolean | No | true | Include converted Markdown in output |
| `includeHtml` | boolean | No | false | Include extracted HTML content in output |

**Either `url` (single mode) or `batchMode: true` with `batchData[]` must be provided.*

---

### Example Input

#### Single Article

```json
{
  "url": "https://example.com/article",
  "includeMarkdown": true,
  "includeHtml": false
}
````

#### Batch Mode (Multiple Articles)

```json
{
  "batchMode": true,
  "batchData": [
    { "url": "https://example.com/article-1" },
    { "url": "https://example.com/article-2" },
    { "url": "https://example.com/article-3" }
  ],
  "includeMarkdown": true,
  "includeHtml": false
}
```

***

### Output Structure

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | The article URL that was processed |
| `title` | string | Extracted article title from og:title or <title> tag |
| `author` | string | Author name from meta tags or JSON-LD |
| `date_published` | string | Publication date in ISO format |
| `domain` | string | Domain of the source URL |
| `excerpt` | string | Article description or excerpt (first 300 chars) |
| `word_count` | integer | Total word count of the extracted content |
| `reading_time_minutes` | integer | Estimated reading time at 200 words/minute |
| `content_markdown` | string | Full article content in Markdown format (when includeMarkdown=true) |
| `content_html` | string | Extracted article as clean HTML (when includeHtml=true) |
| `content_text` | string | Plain text version of the article |
| `content_length` | integer | Length of plain text content in characters |
| `images_count` | integer | Number of images in the extracted content |
| `extraction_method` | string | Method used: readability-lxml or fallback-container |
| `fetch_time_ms` | number | Time to fetch and process in milliseconds |
| `http_status` | integer | HTTP status code from the fetch |
| `content_type` | string | Content-Type of the response |
| `error` | string | Error message if extraction failed |
| `success` | boolean | Whether extraction succeeded |

***

### Use Cases

- **Content migration between CMS platforms** — Moving from WordPress to a static site generator? Extract all articles as Markdown and import them into your new platform with metadata intact.

- **Building NLP datasets** — Researchers and data scientists need clean text for training. Batch-extract thousands of articles with structured metadata for fine-tuning language models.

- **Offline reading pipelines** — Fetch articles from your reading list and save them as Markdown files for offline consumption in any Markdown reader.

- **RSS feed enrichment** — Parse RSS feeds, extract the full article content for each entry, and republish enriched feeds. No more truncated "Read more..." links.

- **Content archival** — Archive important web articles as Markdown files before they disappear. Preserve the content, not just the URL.

- **AI training data preparation** — Extract articles as clean Markdown for LLM training datasets. Remove HTML boilerplate, navigation, and ads in one pass.

- **Documentation migration** — Converting HTML documentation to Markdown for docs-as-code workflows. Preserve formatting while stripping navigation chrome.

***

### FAQ

**What URL types does this support?**
Any public HTML webpage containing article-style content. Works best with news articles, blog posts, documentation pages, and long-form content. May not work well with video pages, product pages, or JavaScript-heavy single-page apps.

**How accurate is the content extraction?**
The readability-lxml algorithm is the same technology behind Firefox Reader View and Pocket. It correctly identifies the main content block on approximately 85–95% of article pages. For pages with unusual layouts, the fallback container extraction may include some non-content elements.

**What happens if the URL requires JavaScript to render content?**
This actor fetches raw HTML, it does not execute JavaScript. For JS-rendered pages (SPAs, React apps), the content may not be available in the initial HTML. For such cases, consider using the Website Content Crawler or a browser-based actor.

**Does this work with paywalled articles?**
Paywalls are site-specific and usually require authentication. This actor does not handle cookies, sessions, or login forms. Public article content is extracted, but paywalled or login-required pages will not return full content.

**How large can the article be?**
The actor accepts up to 5MB of HTML (far larger than any single article). The reading timeout is 60 seconds, sufficient for large multi-page articles. Output size depends on the content but is typically 5–50KB per article in Markdown.

**Can I control what's included in the output?**
Yes. Set `includeMarkdown` to `false` to get only metadata without the full article text. Set `includeHtml` to `true` to include the extracted clean HTML alongside the Markdown. Both default to reasonable values for most use cases.

**How is reading time calculated?**
Standard formula: word count ÷ 200 words per minute, rounded up to the nearest minute. This is the same metric used by Medium, supporting 3+ studies on average adult reading speed.

**What metadata can be extracted?**
Title (from og:title, twitter:title, or <title>), author (from meta author tag or JSON-LD), publication date (from article:published\_time, meta date, or <time> element), and excerpt/description (from og:description or meta description).

**Can I use this in CI/CD pipelines?**
Yes. Call the Apify API with the actor input and parse the dataset output. The structured JSON output is designed for programmatic consumption.

**What languages does it support?**
The extraction works on any language since readability algorithms analyze HTML structure, not content language. Metadata extraction works best with English meta tags but is format-agnostic.

***

### Usage & Billing

This actor uses a pay-per-event pricing model. You are charged only for successful operations:

| Event Name | Price (USD) | Trigger |
|------------|-------------|---------|
| `apify-actor-start` | $0.005 | Every run (once per run) |
| `article-extract` | $0.015 | Per article successfully extracted |
| `convert-markdown` | $0.010 | Per article converted to Markdown |
| `batch-process` | $0.005 | One-time charge when using batch mode |

**Example cost:**

- Single article with Markdown: $0.005 + $0.015 + $0.010 = **$0.03**
- Batch of 5 articles with Markdown: $0.005 + $0.005 + (5 × $0.015) + (5 × $0.010) = **$0.135**

Only successfully extracted articles are charged. Failed fetches or parsing errors are not billed.

***

### MCP Integration

This actor can be used as a tool inside any MCP-compatible AI client (Claude Desktop, Cursor, VS Code with Copilot) via the Apify MCP server.

#### Quick Start

1. Ensure your MCP client is configured to use the Apify MCP server:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}
```

On first connection, your browser will open to sign in to Apify and authorize access.

2. Ask your AI assistant to extract article content. Example prompts:

> "Extract the article from https://example.com/article and return it as Markdown."

> "Fetch these three articles and give me their titles, word counts, and full Markdown content: example.com/article-1, example.com/article-2, example.com/article-3."

#### Bearer Token Alternative

For headless environments (CI/CD, VS Code without browser-based OAuth), configure with a personal API token:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

> **Note:** The OAuth flow is recommended for security. API tokens should be treated as secrets and never committed to version control.

***

### Related Tools

- [Content Readability Analyzer](https://apify.com/perryay/content-readability-analyzer) — Score any text for reading level, grade level, and complexity using Flesch-Kincaid algorithms
- [HTML to Markdown Converter](https://apify.com/perryay/html-to-markdown-converter) — Convert raw HTML input to clean Markdown format
- [Meta Mate — Link Metadata Extractor](https://apify.com/perryay/meta-mate) — Extract Open Graph, Twitter Card, and meta tags from any URL
- [Website Technology Stack Detector](https://apify.com/perryay/website-technology-stack-detector) — Identify the tech stack powering any website

# Actor input Schema

## `url` (type: `string`):

Single article URL to extract content from. Required if batchMode is false.

## `batchMode` (type: `boolean`):

Enable batch processing for multiple URLs

## `batchData` (type: `array`):

List of article URLs to process in batch mode

## `includeMarkdown` (type: `boolean`):

Include converted Markdown content in the output

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

Include extracted HTML content in the output (increases output size)

## Actor input object example

```json
{
  "url": "https://example.com/article",
  "batchMode": false,
  "batchData": [
    {
      "url": "https://example.com/article-1"
    },
    {
      "url": "https://example.com/article-2"
    }
  ],
  "includeMarkdown": true,
  "includeHtml": false
}
```

# Actor output Schema

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

Per-URL article extraction results in the default dataset

# 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 = {
    "url": "https://example.com/article",
    "batchData": [
        {
            "url": "https://example.com/article-1"
        },
        {
            "url": "https://example.com/article-2"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("perryay/article-to-markdown-converter").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 = {
    "url": "https://example.com/article",
    "batchData": [
        { "url": "https://example.com/article-1" },
        { "url": "https://example.com/article-2" },
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("perryay/article-to-markdown-converter").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 '{
  "url": "https://example.com/article",
  "batchData": [
    {
      "url": "https://example.com/article-1"
    },
    {
      "url": "https://example.com/article-2"
    }
  ]
}' |
apify call perryay/article-to-markdown-converter --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Article-to-Markdown Converter 📝",
        "description": "Extract article content from any URL and convert to clean Markdown. Strips navigation, sidebars, and ads using readability algorithms. Returns title, author, date, excerpt, word count, reading time. Batch up to 10 URLs.",
        "version": "1.0",
        "x-build-id": "fLYQahvK3lrAnADdC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/perryay~article-to-markdown-converter/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-perryay-article-to-markdown-converter",
                "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/perryay~article-to-markdown-converter/runs": {
            "post": {
                "operationId": "runs-sync-perryay-article-to-markdown-converter",
                "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/perryay~article-to-markdown-converter/run-sync": {
            "post": {
                "operationId": "run-sync-perryay-article-to-markdown-converter",
                "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": {
                    "url": {
                        "title": "Article URL",
                        "type": "string",
                        "description": "Single article URL to extract content from. Required if batchMode is false."
                    },
                    "batchMode": {
                        "title": "Batch Mode",
                        "type": "boolean",
                        "description": "Enable batch processing for multiple URLs",
                        "default": false
                    },
                    "batchData": {
                        "title": "Batch Data",
                        "type": "array",
                        "description": "List of article URLs to process in batch mode",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "Article URL",
                                    "type": "string",
                                    "description": "URL of the article to extract"
                                }
                            },
                            "required": [
                                "url"
                            ]
                        }
                    },
                    "includeMarkdown": {
                        "title": "Include Markdown",
                        "type": "boolean",
                        "description": "Include converted Markdown content in the output",
                        "default": true
                    },
                    "includeHtml": {
                        "title": "Include HTML",
                        "type": "boolean",
                        "description": "Include extracted HTML content in the output (increases output size)",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```