# Markdown Maker: HTML to Markdown 📝 (`shahidirfan/markdown-maker`) Actor

Instantly convert complex HTML into clean, structured Markdown. This lightweight actor is optimized to render web content into a format that is easily readable for AI LLMs, reducing token usage and improving context. Perfect for RAG pipelines and preparing data for training.

- **URL**: https://apify.com/shahidirfan/markdown-maker.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 6 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Markdown Maker

> **Convert any web page into clean, AI-ready markdown format in seconds.** Perfect for feeding content to AI models, creating documentation, or archiving web content in a portable format.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue)](https://apify.com)
[![Markdown](https://img.shields.io/badge/Format-Markdown-lightgrey)](https://apify.com)
[![AI Ready](https://img.shields.io/badge/AI-Ready-green)](https://apify.com)

### 📋 What This Actor Does

Markdown Maker automatically transforms web pages into clean, well-formatted markdown that's optimized for AI processing and human readability. Whether you're building an AI training dataset, creating documentation, or archiving web content, this tool extracts the main content from any URL and converts it to structured markdown—eliminating ads, navigation menus, and other clutter.

Perfect for:

- **AI Training Data** - Convert documentation and articles into markdown for feeding to language models
- **Content Archiving** - Save web content in a portable, future-proof format
- **Documentation Migration** - Extract content from old sites to import into new documentation platforms
- **Research** - Collect and organize content from multiple sources
- **Data Analysis** - Convert web content to structured format for text analysis

#### ✨ Key Features

- 🎯 **Smart Content Extraction** - Automatically identifies and filters out ads, navigation, and clutter
- 📝 **GitHub-Flavored Markdown** - Clean, standardized markdown with proper table syntax and formatting
- ⚡ **Batch Processing** - Process multiple URLs at once with optional delays
- 🔒 **Reliable Scraping** - Built-in proxy rotation and retry logic for consistent results
- 🌐 **Universal Compatibility** - Works on any website including JavaScript-heavy pages
- 🚀 **Production Ready** - Optimized for speed and reliability

### 🚀 Quick Start

#### Basic Usage - Single URL

```json
{
  "startUrls": [
    {
      "url": "https://docs.apify.com/api/v2"
    }
  ]
}
````

#### Multiple URLs

```json
{
  "startUrls": [
    {
      "url": "https://docs.apify.com/api/v2"
    },
    {
      "url": "https://example.com/article"
    },
    {
      "url": "https://blog.example.com/post"
    }
  ],
  "maxItems": 10
}
```

#### With Rate Limiting

```json
{
  "startUrls": [
    {
      "url": "https://docs.example.com/page1"
    },
    {
      "url": "https://docs.example.com/page2"
    }
  ],
  "delayBetweenRequests": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### 📊 Input Parameters

| Parameter | Type | Required | Description | Example |
|-----------|------|----------|-------------|---------|
| `startUrls` | array | ✅ Yes | List of URLs to convert to markdown | `[{"url": "https://example.com"}]` |
| `maxItems` | integer | ❌ No | Maximum number of pages to process | `10` (default: unlimited) |
| `delayBetweenRequests` | integer | ❌ No | Seconds to wait between processing each URL (0-300) | `2` (default: 0) |
| `proxyConfiguration` | object | ❌ No | Proxy settings for reliable access | `{"useApifyProxy": true}` |

### 📈 Output Data Structure

Each converted page provides clean markdown with metadata:

```json
{
  "url": "https://docs.apify.com/api/v2",
  "title": "Apify API Documentation",
  "markdown": "# Apify API Documentation\n\n**URL Source:** https://docs.apify.com/api/v2\n\n---\n\nThe Apify API provides programmatic access...\n\n## Authentication\n\n...",
  "timestamp": "2024-12-13T10:30:00.000Z"
}
```

#### Output Fields

- **`url`** - Source web page URL
- **`title`** - Extracted page title
- **`markdown`** - Full content converted to clean markdown format
- **`timestamp`** - When the page was processed

#### Markdown Format Features

- ✅ Proper heading hierarchy (H1-H6)
- ✅ Clean table syntax with pipes (`|`)
- ✅ Bullet points using asterisks (`*`)
- ✅ Code blocks with triple backticks
- ✅ Strikethrough and emphasis preserved
- ✅ Horizontal rules under major sections
- ✅ Source URL included in output

### 🎯 Use Cases & Applications

#### AI & Machine Learning

- **Training Data Preparation** - Convert documentation for AI model training
- **RAG Systems** - Prepare content for retrieval-augmented generation
- **Knowledge Bases** - Build searchable AI knowledge repositories
- **Prompt Engineering** - Create clean context for LLM prompts

#### Documentation & Content

- **Documentation Migration** - Move content to modern markdown-based systems
- **Content Archiving** - Preserve web content in portable format
- **Static Site Generation** - Feed content to Jekyll, Hugo, or Next.js
- **Knowledge Management** - Build internal wikis and documentation

#### Research & Analysis

- **Academic Research** - Collect and analyze web content
- **Market Research** - Extract competitor information
- **Text Mining** - Prepare web data for NLP analysis
- **Content Monitoring** - Track changes to web pages over time

### ⚡ Performance & Cost Optimization

#### Recommended Settings for Different Use Cases

| Use Case | Max Items | Delay | Est. Time |
|----------|-----------|-------|-----------|
| Quick Test | 5 | 0 | ~30 seconds |
| Documentation Site | 50 | 1 | ~2 minutes |
| Content Archive | 200 | 2 | ~8 minutes |
| Large Dataset | 500+ | 2 | ~20 minutes |

#### Plan Limits

- **Free Plan**: Limited to 100 pages per run
- **Paid Plans**: Unlimited page processing

[Upgrade to a paid plan](https://apify.com/pricing) to process unlimited pages.

#### Best Practices

- **Start Small**: Test with 5-10 URLs first to verify output quality
- **Use Delays**: Set `delayBetweenRequests` to avoid overwhelming servers
- **Enable Proxies**: Use Apify Proxy for reliable access to any website
- **Batch Processing**: Process URLs in batches for better control
- **Monitor Output**: Check markdown quality and adjust as needed

### 🔧 Configuration Examples

#### Documentation Site

Convert entire documentation site for AI training:

```json
{
  "startUrls": [
    {"url": "https://docs.example.com/getting-started"},
    {"url": "https://docs.example.com/api-reference"},
    {"url": "https://docs.example.com/tutorials"}
  ],
  "maxItems": 50,
  "delayBetweenRequests": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

#### Blog Archive

Archive blog posts in markdown format:

```json
{
  "startUrls": [
    {"url": "https://blog.example.com/2024/post-1"},
    {"url": "https://blog.example.com/2024/post-2"}
  ],
  "maxItems": 100,
  "delayBetweenRequests": 2
}
```

#### Research Collection

Gather content from multiple sources:

```json
{
  "startUrls": [
    {"url": "https://wikipedia.org/wiki/Topic"},
    {"url": "https://example.com/research-paper"},
    {"url": "https://news.example.com/article"}
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

#### Quick Single Page

Convert a single page quickly:

```json
{
  "startUrls": [
    {"url": "https://example.com/important-page"}
  ]
}
```

### 📋 Supported Content & Features

#### Website Compatibility

- ✅ Static HTML pages
- ✅ JavaScript-rendered content (SPA, React, Vue, Angular)
- ✅ Documentation sites (GitBook, Docusaurus, MkDocs)
- ✅ Blog platforms (WordPress, Medium, Ghost)
- ✅ Wiki pages (Wikipedia, Confluence)
- ✅ News articles and magazines
- ✅ Product pages and landing pages

#### Content Extraction

- **Smart Filtering**: Automatically removes ads, navigation, footers, and sidebars
- **Semantic Analysis**: Identifies main content using multiple algorithms
- **Structure Preservation**: Maintains headings, lists, tables, and code blocks
- **Link Handling**: Preserves hyperlinks in markdown format
- **Image Alt Text**: Includes image descriptions when available

#### Language Support

- Works with any language (Unicode support)
- Preserves special characters and formatting
- Handles RTL (right-to-left) text

### 🆘 Troubleshooting

#### Common Issues

**Empty or Poor Quality Markdown**

- Page may have aggressive anti-scraping measures
- Enable `proxyConfiguration` with Apify Proxy
- Some pages may have no extractable content
- Try increasing `delayBetweenRequests`

**Timeout Errors**

- Reduce the number of URLs in `startUrls`
- Increase `delayBetweenRequests` to slow down processing
- Enable proxy configuration for better reliability
- Split large jobs into smaller batches

**Missing Content**

- JavaScript-heavy sites may need more processing time
- Some content may be dynamically loaded after page render
- Check if the page requires authentication

**Rate Limiting**

- Increase `delayBetweenRequests` (e.g., 2-5 seconds)
- Enable Apify Proxy to rotate IP addresses
- Process fewer URLs per run

#### Support

For issues or feature requests:

- **Email**: Contact via Google Form
- **Documentation**: Check Apify documentation
- **Community**: Visit Apify Discord community

We're here to help! Fill out the form at https://docs.google.com/forms/d/e/1FAIpQLSfsKyzZ3nRED7mML47I4LAfNh\_mBwkuFMp1FgYYJ4AkDRgaRw/viewform to get support.

### � Export Options

The Apify platform provides multiple ways to export your markdown data:

#### JSON Format

Perfect for programmatic use or integration with other tools:

```json
[
  {
    "url": "https://example.com",
    "title": "Example Page",
    "markdown": "# Example Page\n\n..."
  }
]
```

#### CSV Format

Great for opening in Excel or Google Sheets - each row contains one URL and its markdown content.

#### Integration Options

- **Webhooks** - Send results to your own API
- **Google Sheets** - Automatically populate a spreadsheet
- **Make.com / Zapier** - Trigger workflows based on results
- **Other Apify Actors** - Chain multiple actors together

### 🔗 API Integration

Access your results programmatically:

```bash
## Get the dataset
curl https://api.apify.com/v2/datasets/{DATASET_ID}/items
```

Results are stored in Apify's dataset storage and remain available for download even after the actor finishes running.

### 📄 License & Terms

This actor extracts publicly available web content in accordance with applicable web scraping regulations and respects robots.txt directives.

***

**Built with ❤️ by Shahid**

**Keywords**: markdown converter, web scraping, ai training data, content extraction, documentation tools, markdown generator, web to markdown, apify actor, content archiving, ai-ready data

# Actor input Schema

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

URLs to convert to markdown

## `maxItems` (type: `integer`):

Maximum number of pages to process (optional)

## `delayBetweenRequests` (type: `integer`):

Number of seconds to wait between processing each URL. Useful to prevent server overload or avoid rate limiting. Leave empty or set to 0 for no delay (default).

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

Proxy settings for the scraper

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apify.com/shahidirfan/dice-job-scraper"
    }
  ],
  "delayBetweenRequests": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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://apify.com/shahidirfan/dice-job-scraper"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahidirfan/markdown-maker").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://apify.com/shahidirfan/dice-job-scraper" }] }

# Run the Actor and wait for it to finish
run = client.actor("shahidirfan/markdown-maker").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://apify.com/shahidirfan/dice-job-scraper"
    }
  ]
}' |
apify call shahidirfan/markdown-maker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Markdown Maker: HTML to Markdown 📝",
        "description": "Instantly convert complex HTML into clean, structured Markdown. This lightweight actor is optimized to render web content into a format that is easily readable for AI LLMs, reducing token usage and improving context. Perfect for RAG pipelines and preparing data for training.",
        "version": "0.0",
        "x-build-id": "KqmwQhvt7bpTE8zkQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shahidirfan~markdown-maker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shahidirfan-markdown-maker",
                "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/shahidirfan~markdown-maker/runs": {
            "post": {
                "operationId": "runs-sync-shahidirfan-markdown-maker",
                "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/shahidirfan~markdown-maker/run-sync": {
            "post": {
                "operationId": "run-sync-shahidirfan-markdown-maker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "URLs to convert to markdown",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "description": "The URL of the web page to convert to markdown"
                                }
                            },
                            "required": [
                                "url"
                            ]
                        }
                    },
                    "maxItems": {
                        "title": "Maximum Number of Pages to Process",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of pages to process (optional)"
                    },
                    "delayBetweenRequests": {
                        "title": "Delay Between Requests",
                        "minimum": 0,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Number of seconds to wait between processing each URL. Useful to prevent server overload or avoid rate limiting. Leave empty or set to 0 for no delay (default).",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```