# Markdown to PDF MCP Server (`parseforge/markdown-to-pdf-mcp`) Actor

Convert Markdown content to PDF format using Model Context Protocol (MCP). Perfect for developers, content creators, and businesses who need to programmatically convert Markdown documents to professional PDFs with custom styling, page sizes, margins, and orientations.

- **URL**: https://apify.com/parseforge/markdown-to-pdf-mcp.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** MCP servers, Developer tools, Other
- **Stats:** 8 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per event

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📄 Markdown to PDF MCP Server

> 🚀 **Convert Markdown to professional PDFs instantly.** Send Markdown content via the Model Context Protocol and receive beautifully formatted PDF documents. Custom page sizes, margins, orientations, and CSS styling supported.

> 🕒 **Last updated:** 2026-04-23 · **📄 MCP-based** conversion · **🎨 Custom CSS** styling · **📐 Multiple page sizes** (A4, Letter, Legal) · **🚫 No coding** required

The **Markdown to PDF MCP Server** converts Markdown content into professional PDF documents using the Model Context Protocol (MCP). It supports custom page sizes, margins, orientations, headers, footers, and CSS styling, all delivered through a standard MCP interface.

Whether you are a developer integrating PDF generation into applications, a content creator producing branded documents, or a technical writer converting documentation for distribution, this tool generates professional PDFs from any Markdown input.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Developers, content creators, technical writers, businesses needing document automation | Report generation, documentation export, invoice creation, automated PDF workflows, content publishing |

---

### 📋 What the Markdown to PDF MCP Server does

- 📄 **Markdown to PDF.** Convert any Markdown content into a formatted PDF document.
- 📐 **Page formats.** Choose from A4, Letter, Legal, and other standard page sizes.
- 🎨 **Custom CSS.** Apply your own styles for branded, consistent documents.
- 📏 **Margins and orientation.** Set custom margins and switch between portrait and landscape.
- 📝 **Headers and footers.** Add page numbers, dates, or custom text to every page.
- 🖼️ **Background graphics.** Render background images and colors in the output PDF.

Each response returns a base64-encoded PDF ready for download, storage, or further processing.

> 💡 **Why it matters:** generating professional PDFs from Markdown content typically requires setting up rendering pipelines, installing libraries, and managing dependencies. This MCP server handles everything in a single API call.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>markdown</td><td>string</td><td>-</td><td>Markdown content to convert to PDF.</td></tr>
<tr><td>options.format</td><td>string</td><td>"A4"</td><td>Page size: A4, Letter, Legal, etc.</td></tr>
<tr><td>options.orientation</td><td>string</td><td>"portrait"</td><td>Page orientation: portrait or landscape.</td></tr>
<tr><td>options.margin</td><td>object</td><td>default</td><td>Custom margins (top, right, bottom, left).</td></tr>
<tr><td>options.css</td><td>string</td><td>-</td><td>Custom CSS styling for the document.</td></tr>
</tbody>
</table>

**Example: simple Markdown conversion.**

```json
{
    "method": "tools/call",
    "params": {
        "name": "markdown_to_pdf",
        "arguments": {
            "markdown": "# Hello World\n\nThis is a **test** PDF document.",
            "options": {
                "format": "A4",
                "orientation": "portrait"
            }
        }
    }
}
````

**Example: landscape Letter with custom margins.**

```json
{
    "method": "tools/call",
    "params": {
        "name": "markdown_to_pdf",
        "arguments": {
            "markdown": "# Quarterly Report\n\n| Q1 | Q2 | Q3 | Q4 |\n|---|---|---|---|\n| 100 | 120 | 135 | 150 |",
            "options": {
                "format": "Letter",
                "orientation": "landscape",
                "margin": { "top": "1in", "right": "1in", "bottom": "1in", "left": "1in" }
            }
        }
    }
}
```

> ⚠️ **Good to Know:** This Actor runs in standby mode. Deploy it once, then send MCP requests to the standby URL. Pass your Apify API token in the Authorization header.

***

### 📊 Output

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| ✅ `success` | boolean | `true` |
| 📄 `pdf` | string (base64) | `"JVBERi0xLjQKJeLjz9MK..."` |
| 📏 `size` | integer | `12345` |
| 📦 `format` | string | `"base64"` |

#### 📦 Sample records

<details><summary><strong>📄 Successful PDF conversion</strong></summary>

```json
{
    "content": [
        {
            "type": "text",
            "text": "{\n  \"success\": true,\n  \"pdf\": \"JVBERi0xLjQKJeLjz9MK...\",\n  \"size\": 12345,\n  \"format\": \"base64\"\n}"
        }
    ]
}
```

</details>

<details><summary><strong>❌ Error response</strong></summary>

```json
{
    "content": [
        {
            "type": "text",
            "text": "{\n  \"success\": false,\n  \"error\": \"Invalid markdown content provided\"\n}"
        }
    ]
}
```

</details>

<details><summary><strong>📐 Landscape report output</strong></summary>

```json
{
    "content": [
        {
            "type": "text",
            "text": "{\n  \"success\": true,\n  \"pdf\": \"JVBERi0xLjQKJdPT09...\",\n  \"size\": 28901,\n  \"format\": \"base64\"\n}"
        }
    ]
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 📄 | **Professional quality.** High-fidelity PDF rendering with proper formatting. |
| 🎨 | **Custom styling.** Full CSS support for branded documents. |
| 📐 | **Multiple formats.** A4, Letter, Legal, and custom page sizes. |
| ⚡ | **Instant response.** Standby mode ensures fast turnaround. |
| 🔌 | **Standard protocol.** MCP interface works with any compatible client. |
| 📝 | **Headers and footers.** Page numbers, dates, and custom text. |
| 💰 | **Pay per use.** Only pay for conversions you run. |

> 📊 Supports **all standard Markdown features** including headers, bold/italic, lists, links, images, code blocks, tables, and blockquotes.

***

### 📈 How it compares to alternatives

| Approach | Cost | Features | Setup | Speed |
|---|---|---|---|---|
| **⭐ Markdown to PDF MCP** *(this Actor)* | $5 free credit | Full styling, headers, footers | ⚡ 5 min | Instant |
| Self-hosted rendering pipeline | Server costs | Full control | 🕒 Hours | Varies |
| Manual export from editor | Free | Limited | 🕒 Per document | Slow |
| Browser print-to-PDF | Free | Basic | 🕒 Manual | Slow |

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Deploy the Actor.** Enable standby mode in Actor settings.
3. 🔗 **Get the endpoint.** Copy your standby URL for MCP requests.
4. 🚀 **Send a request.** POST your Markdown content via the MCP protocol.
5. 📥 **Get your PDF.** Decode the base64 response to save your PDF file.

> ⏱️ Total time: **5 minutes setup**, then instant conversions.

***

### 💼 Business use cases

<table>
<tr><td width="50%" valign="top">

#### 📄 Content & Documentation

- Automate report generation from Markdown
- Convert blog posts to PDF for distribution
- Create branded technical documentation
- Generate print-ready materials

</td><td width="50%" valign="top">

#### 🔧 Development & Automation

- Integrate PDF generation into applications
- Convert API docs to PDF format
- Generate invoices from Markdown templates
- Build document pipelines with MCP

</td></tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

***

### 🔌 Automating Markdown to PDF MCP Server

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Markdown%20to%20PDF%20MCP%20Server%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Markdown%20to%20PDF%20MCP%20Server%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Markdown%20to%20PDF%20MCP%20Server%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Markdown%20to%20PDF%20MCP%20Server%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

The server runs in standby mode and accepts MCP protocol requests. Send Markdown content and receive a base64-encoded PDF in the response.

#### 📝 What Markdown features are supported?

All standard features: headers, bold/italic text, lists, links, images, code blocks, tables, and blockquotes.

#### 🎨 Can I customize the PDF appearance?

Yes. You can set page size, margins, orientation, and apply custom CSS styling. Headers and footers with page numbers are also supported.

#### ⚖️ Is this legal to use commercially?

Yes. You are converting your own Markdown content into PDF format. There are no restrictions on commercial use.

#### 💳 Do I need a paid Apify plan?

No. The free plan with $5 credit covers many conversions. Upgrade for higher volumes.

#### 🔁 What happens if a conversion fails?

The response includes a success flag and a detailed error message so you can diagnose the issue.

#### 📅 Can I schedule regular conversions?

Yes. Use the Apify API to schedule document generation or integrate with automation tools like Make or Zapier.

#### 🔒 Is my data secure?

All requests require authentication with your Apify API token. Data is processed securely on the Apify platform.

#### 📐 What page sizes are available?

A4, Letter, Legal, Tabloid, and other standard sizes. You can also set custom dimensions.

#### ⚡ How fast are conversions?

Standby mode ensures instant response times. Most conversions complete in under a second.

#### 🆘 What if I need help?

Contact us via the Tally form linked below or check the Apify documentation.

***

### 🔌 Integrate with any app

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate document workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get notifications
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Data pipelines
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger from commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export to Drive

***

### 🔗 Recommended Actors

- [**🏢 HubSpot Marketplace Scraper**](https://apify.com/parseforge/hubspot-marketplace-scraper) - Business app data
- [**📰 PR Newswire Scraper**](https://apify.com/parseforge/pr-newswire-scraper) - Press releases
- [**🤗 Hugging Face Model Scraper**](https://apify.com/parseforge/hugging-face-model-scraper) - AI model data
- [**💰 FINRA BrokerCheck Scraper**](https://apify.com/parseforge/finra-brokercheck-scraper) - Broker data
- [**📊 Pitchbook Funds Scraper**](https://apify.com/parseforge/pitchbook-funds-scraper) - Investment fund data

> 💡 Browse the complete [ParseForge collection](https://apify.com/parseforge).

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper or report an issue.

***

> **⚠️ Disclaimer:** Independent tool, not affiliated with any Markdown or PDF-related companies or organizations. All trademarks mentioned are the property of their respective owners.

# Actor input Schema

## Actor input object example

```json
{}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/markdown-to-pdf-mcp").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/markdown-to-pdf-mcp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call parseforge/markdown-to-pdf-mcp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Markdown to PDF MCP Server",
        "description": "Convert Markdown content to PDF format using Model Context Protocol (MCP). Perfect for developers, content creators, and businesses who need to programmatically convert Markdown documents to professional PDFs with custom styling, page sizes, margins, and orientations.",
        "version": "0.2",
        "x-build-id": "WCuFsgDERUTtSbx67"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~markdown-to-pdf-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-markdown-to-pdf-mcp",
                "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/parseforge~markdown-to-pdf-mcp/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-markdown-to-pdf-mcp",
                "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/parseforge~markdown-to-pdf-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-markdown-to-pdf-mcp",
                "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": {}
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
