# Markdownify MCP Server (`maximedupre/markdownify-mcp-server`) Actor

Markdownify MCP Server converts webpage URLs to clean Markdown for AI, RAG, docs, and migration workflows. Batch URLs, render JavaScript pages, tune selectors, and export source-backed results.

- **URL**: https://apify.com/maximedupre/markdownify-mcp-server.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 converted pages

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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

### 🧾 Convert HTML to Markdown for AI workflows

Markdownify MCP Server converts webpage URLs into clean Markdown rows you can use in RAG pipelines, agent tools, documentation archives, and content migration jobs. Add one URL or a batch of URLs, choose static or JavaScript rendering, and get source-backed Markdown with conversion facts in the dataset.

- [Convert HTML to Markdown](https://apify.com/maximedupre/markdownify-mcp-server/examples/convert-html-to-markdown) from public or HTTP Basic Auth protected webpages without writing a crawler.
- [Build RAG-ready Markdown](https://apify.com/maximedupre/markdownify-mcp-server/examples/rag-ready-markdown) from documentation, articles, landing pages, and knowledge base pages.
- [Use markdownify-style output](https://apify.com/maximedupre/markdownify-mcp-server/examples/markdownify-style-output) for Python, agent, and data workflows that need plain Markdown instead of raw HTML.
- [Compare static and JavaScript-rendered page conversion](https://apify.com/maximedupre/markdownify-mcp-server/examples/javascript-rendered-page-conversion) when important content loads after the first response.
- [Clean page boilerplate](https://apify.com/maximedupre/markdownify-mcp-server/examples/clean-page-boilerplate) with include selectors, exclude selectors, stripped tags, and default navigation cleanup.

#### 📦 Returned data

Each successful webpage conversion is saved as one dataset row. The actor returns the submitted URL, final URL, source title, source meta description when available, Markdown content, Markdown length, conversion timestamp, and the settings used for conversion.

The `conversion` object shows whether the page was loaded with static fetching or JavaScript rendering. It also records the heading style, include selectors, exclude selectors, and stripped tags applied to that row. This makes each result easy to trace back to the input and easy to audit before sending it to an AI system or downstream database.

Failed pages are handled per URL. One bad target does not block successful rows from other URLs in the same run.

#### 🚀 How to run

1. Add one or more webpage URLs in the input.
2. Leave JavaScript rendering off for faster static pages, or turn it on when the page needs browser rendering.
3. Keep the default cleanup settings, or add include and exclude CSS selectors when you need a specific page area.
4. Choose ATX or SETEXT heading style.
5. Add HTTP Basic Auth credentials only for pages that require them.
6. Run the actor and open the dataset, API endpoint, or export file.

Good first targets include docs pages, help center articles, blog posts, product documentation, and public knowledge base pages.

#### 🧩 Input

The required input is `startUrls`, a list of webpage URLs. Optional controls let you tune the conversion:

- `useJavaScript` renders pages in a browser before conversion.
- `includeSelectors` limits Markdown to matching areas such as `main` or `article`.
- `excludeSelectors` removes areas such as navigation, footers, ads, and sidebars.
- `stripTags` removes tag names such as `script`, `style`, `iframe`, and `noscript`.
- `headingStyle` sets Markdown headings to ATX (`# Heading`) or SETEXT.
- `basicAuthUsername` and `basicAuthPassword` support HTTP Basic Auth protected pages.

No source API key, cookie, browser extension, or external paid API is required for ordinary public pages.

#### 📄 Output example

```json
{
  "submittedUrl": "https://docs.apify.com/platform/actors",
  "url": "https://docs.apify.com/platform/actors/",
  "title": "Actors | Apify Documentation",
  "description": "Learn how to build, run, and publish Apify Actors.",
  "markdown": "# Actors\n\nActors are serverless cloud programs that can perform web scraping, automation, and data processing tasks.",
  "markdownLength": 14237,
  "convertedAt": "2026-07-01T12:34:56.000Z",
  "conversion": {
    "rendering": "static",
    "headingStyle": "atx",
    "includeSelectors": ["main", "article"],
    "excludeSelectors": ["nav", "footer", ".advertisement", "aside"],
    "strippedTags": ["script", "style", "iframe", "noscript"]
  }
}
````

#### 💳 Pricing

This actor uses pay-per-event pricing. You are charged for each successful webpage converted to Markdown and emitted as a dataset row. Failed URLs, empty results, and actor starts are not charged as converted-page events.

The planned event is `converted-page`: one webpage successfully converted to Markdown and emitted as a result.

#### 🔌 Integrations

https://www.youtube.com/watch?v=bNACk1\_S\_6w\&list=PLObrtcm1Kw6MUrlLNDbK9QRg8VDJg0gOW\&index=4

- Use the dataset API to pull Markdown rows into an app, vector database, or content pipeline.
- Export results as JSON, CSV, Excel, XML, or RSS from Apify datasets.
- Schedule repeated runs to refresh documentation or website content snapshots.
- Connect webhooks to start downstream processing after a run finishes.
- Run the actor from Apify API clients when you need URL-to-Markdown conversion inside a larger workflow.

#### ❓ FAQ

##### Can I use this for html to markdown Python workflows?

Yes. Run the actor with URLs, then fetch the dataset rows from the Apify API in Python. The output includes Markdown text and source metadata, so your Python code does not need to parse the page HTML itself.

##### Is this the same as the markdownify Python package?

No. The actor is a hosted URL-to-Markdown conversion workflow. It fetches webpages, optionally renders JavaScript, applies cleanup settings, and returns dataset rows. The Python package is a library you run inside your own code.

##### Can it replace pandoc html to markdown for webpages?

It can help when your source is live webpages and you want Apify runs, datasets, exports, schedules, and API access. It is not a general local document converter and does not claim to support every Pandoc format.

##### Can it convert JavaScript-heavy pages?

Yes, turn on JavaScript rendering for pages where important content appears only after browser rendering. Static fetching remains available for simpler pages.

##### Can I convert password-protected pages?

Yes, if the page uses HTTP Basic Auth. Add the username and password in the Basic Auth fields. The actor does not support logging into arbitrary websites with forms or cookies.

##### Why not use the website API?

Many websites do not expose a clean API for page content, and APIs often return structured data instead of readable Markdown. This actor works from webpage URLs and returns Markdown for documentation, RAG, and migration workflows.

##### What are website-to-Markdown alternatives?

Alternatives include running a local converter such as Pandoc or markdownify in your own code, using another Apify URL-to-Markdown actor, or writing a custom scraper. This actor is useful when you want hosted runs, batching, dataset exports, and Apify integrations.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~markdownify-mcp-server/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Glama MCP Registry Scraper ↗](https://apify.com/maximedupre/glama-mcp-registry-scraper) - Collect MCP server listings and metadata from Glama.
- [Website URL Crawler ↗](https://apify.com/maximedupre/website-url-crawler) - Discover URLs from a website before converting selected pages.
- [Font Detector ↗](https://apify.com/maximedupre/font-detector) - Detect fonts used on webpages for design and audit workflows.
- [Ahrefs Free Website Stats Scraper ↗](https://apify.com/maximedupre/ahrefs-free-website-stats-scraper) - Get public Ahrefs website stats for SEO research.
- [SEMrush Free Website Stats Scraper ↗](https://apify.com/maximedupre/semrush-free-website-stats-scraper) - Collect public SEMrush website stats for competitor and SEO checks.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Add one or more public or authenticated webpage URLs to convert.

## `useJavaScript` (type: `boolean`):

Turn on for websites that need browser rendering before their main content appears.

## `includeSelectors` (type: `array`):

Limit Markdown to matching page areas, such as article or main.

## `excludeSelectors` (type: `array`):

Remove matching page areas such as navigation, footers, ads, or sidebars.

## `stripTags` (type: `array`):

Remove these tag names before converting the page to Markdown.

## `headingStyle` (type: `string`):

Choose the Markdown heading format for converted headings.

## `basicAuthUsername` (type: `string`):

Use only for pages protected by HTTP Basic Auth.

## `basicAuthPassword` (type: `string`):

Password for HTTP Basic Auth protected pages.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://docs.apify.com/platform/actors"
    },
    {
      "url": "https://docs.apify.com/platform/actors/development"
    },
    {
      "url": "https://docs.apify.com/platform/actors/running"
    },
    {
      "url": "https://docs.apify.com/platform/storage/dataset"
    },
    {
      "url": "https://docs.apify.com/api/v2"
    }
  ],
  "useJavaScript": false,
  "includeSelectors": [
    "main",
    "article"
  ],
  "excludeSelectors": [
    "nav",
    "footer",
    ".advertisement",
    "aside"
  ],
  "stripTags": [
    "script",
    "style",
    "iframe",
    "noscript"
  ],
  "headingStyle": "atx"
}
```

# Actor output Schema

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

View Markdown rows with source URLs, page titles, converted content, timestamps, and conversion settings.

# 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://docs.apify.com/platform/actors"
        },
        {
            "url": "https://docs.apify.com/platform/actors/development"
        },
        {
            "url": "https://docs.apify.com/platform/actors/running"
        },
        {
            "url": "https://docs.apify.com/platform/storage/dataset"
        },
        {
            "url": "https://docs.apify.com/api/v2"
        }
    ],
    "includeSelectors": [
        "main",
        "article"
    ],
    "excludeSelectors": [
        "nav",
        "footer",
        ".advertisement",
        "aside"
    ],
    "stripTags": [
        "script",
        "style",
        "iframe",
        "noscript"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/markdownify-mcp-server").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://docs.apify.com/platform/actors" },
        { "url": "https://docs.apify.com/platform/actors/development" },
        { "url": "https://docs.apify.com/platform/actors/running" },
        { "url": "https://docs.apify.com/platform/storage/dataset" },
        { "url": "https://docs.apify.com/api/v2" },
    ],
    "includeSelectors": [
        "main",
        "article",
    ],
    "excludeSelectors": [
        "nav",
        "footer",
        ".advertisement",
        "aside",
    ],
    "stripTags": [
        "script",
        "style",
        "iframe",
        "noscript",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/markdownify-mcp-server").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://docs.apify.com/platform/actors"
    },
    {
      "url": "https://docs.apify.com/platform/actors/development"
    },
    {
      "url": "https://docs.apify.com/platform/actors/running"
    },
    {
      "url": "https://docs.apify.com/platform/storage/dataset"
    },
    {
      "url": "https://docs.apify.com/api/v2"
    }
  ],
  "includeSelectors": [
    "main",
    "article"
  ],
  "excludeSelectors": [
    "nav",
    "footer",
    ".advertisement",
    "aside"
  ],
  "stripTags": [
    "script",
    "style",
    "iframe",
    "noscript"
  ]
}' |
apify call maximedupre/markdownify-mcp-server --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Markdownify MCP Server",
        "description": "Markdownify MCP Server converts webpage URLs to clean Markdown for AI, RAG, docs, and migration workflows. Batch URLs, render JavaScript pages, tune selectors, and export source-backed results.",
        "version": "0.1",
        "x-build-id": "HLfHtZaGZqcPdNUsS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~markdownify-mcp-server/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-markdownify-mcp-server",
                "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/maximedupre~markdownify-mcp-server/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-markdownify-mcp-server",
                "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/maximedupre~markdownify-mcp-server/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-markdownify-mcp-server",
                "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": "Webpage URLs",
                        "type": "array",
                        "description": "Add one or more public or authenticated webpage URLs to convert.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "useJavaScript": {
                        "title": "Render pages with JavaScript",
                        "type": "boolean",
                        "description": "Turn on for websites that need browser rendering before their main content appears.",
                        "default": false
                    },
                    "includeSelectors": {
                        "title": "Include CSS selectors",
                        "type": "array",
                        "description": "Limit Markdown to matching page areas, such as article or main.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeSelectors": {
                        "title": "Exclude CSS selectors",
                        "type": "array",
                        "description": "Remove matching page areas such as navigation, footers, ads, or sidebars.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "stripTags": {
                        "title": "Strip HTML tags",
                        "type": "array",
                        "description": "Remove these tag names before converting the page to Markdown.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "headingStyle": {
                        "title": "Heading style",
                        "enum": [
                            "atx",
                            "setext"
                        ],
                        "type": "string",
                        "description": "Choose the Markdown heading format for converted headings.",
                        "default": "atx"
                    },
                    "basicAuthUsername": {
                        "title": "Basic Auth username",
                        "type": "string",
                        "description": "Use only for pages protected by HTTP Basic Auth."
                    },
                    "basicAuthPassword": {
                        "title": "Basic Auth password",
                        "type": "string",
                        "description": "Password for HTTP Basic Auth protected pages."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```