# Text Cleaner For RAG (`junipr/text-cleaner-for-rag`) Actor

Clean web text for RAG by removing boilerplate, normalizing whitespace, and producing chunk-ready text.

- **URL**: https://apify.com/junipr/text-cleaner-for-rag.md
- **Developed by:** [junipr](https://apify.com/junipr) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.90 / 1,000 item checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Text Cleaner For RAG

### Store Positioning

**Store title:** Text Cleaner For RAG

**Short description:** Clean web text for RAG by removing boilerplate, normalizing whitespace, and producing chunk-ready text.

**SEO title:** Text Cleaner For RAG — fast deterministic data utility

**SEO description:** Clean web text for RAG by removing boilerplate, normalizing whitespace, and producing chunk-ready text. Use it for fast, low-cost normalization or validation at scale with predictable pay-per-event pricing.

**Categories:** DEVELOPER_TOOLS

**Keywords:** text, cleaner, rag, web audit, tiny deterministic utility

### Pay-Per-Event Pricing

This actor uses pay-per-event pricing. Event prices include Apify platform usage; users are not expected to pay a separate platform-usage pass-through charge for the configured pricing model.

- Primary event: `identifier-validated` at $0.00195 base

Event set:

- `actor-start`: $0.00176 when run setup is accepted.
- `identifier-validated`: $0.00195 for each cleaned chunk emitted to the dataset. This event name is fixed by the actor pricing contract.
- `report-generated`: $0.02000 when cleaned Markdown, chunk JSON, summary, and report files are created.

### Public Task Concepts

- Normalize Text Cleaner For RAG records
- Validate Text Cleaner For RAG values in bulk
- Generate a small utility report for Text Cleaner For RAG
- Clean HTML into retrieval-ready text
- Chunk documents for a RAG pipeline

Clean web text for RAG by removing boilerplate, normalizing whitespace, and producing chunk-ready text from supplied text or HTML.

### What This Actor Does

Text Cleaner For RAG accepts user-supplied text, HTML, or document objects and produces dataset rows that are ready for embedding or retrieval preprocessing:

- Strips script/style/svg/no-script blocks from HTML.
- Converts HTML structure into readable text.
- Removes common cookie, newsletter, social, navigation, and footer boilerplate lines.
- Deduplicates repeated normalized lines inside each document.
- Normalizes whitespace while preserving useful headings by default.
- Splits cleaned text into size-bounded chunks with optional overlap.
- Writes cleaned Markdown, chunk JSON, and Markdown/JSON summary reports.

### What This Actor Does Not Do

- It does not crawl pages or fetch remote URLs.
- It does not call an embedding model, LLM, vector database, or paid API.
- It does not classify factual accuracy or content safety.
- It does not guarantee legal, privacy, or copyright compliance for uploaded text.

### Best Use Cases

- Clean scraped page text before embedding.
- Remove repeated navigation or cookie banner text from documentation exports.
- Turn supplied HTML snippets into retrieval chunks.
- Create traceable chunk rows for retrieval QA and prompt experiments.
- Validate a small batch before running a larger ingestion pipeline.

### Input Fields

- `documents`: Array of document objects with `id`, `title`, `sourceUrl`, `text`, or `html`.
- `text`: Optional single plain-text document.
- `html`: Optional single HTML document.
- `chunkSize`: Target maximum characters per chunk.
- `chunkOverlap`: Approximate character overlap between adjacent chunks.
- `minChunkChars`: Threshold for warning about short chunks.
- `removeBoilerplate`: Remove common web boilerplate lines.
- `dedupeRepeatedLines`: Drop repeated normalized lines.
- `stripMarkdownLinks`: Convert markdown links to visible text.
- `preserveHeadings`: Keep markdown heading markers for retrieval context.
- `maxDocuments`: Maximum documents to process. Default is 25 and hard cap is 1,000.
- `maxItems`: Maximum output chunks across all documents. Default is 100 and hard cap is 10,000.
- `maxTextBytes`: Maximum UTF-8 bytes cleaned from each document. Default is 1,000,000.
- `includeReport`: Store cleaned Markdown, chunk JSON, and summary report artifacts.

### Example Input

```json
{
  "text": "Cookie settings\n# Product Documentation\nThis guide explains production setup.\nThis guide explains production setup.",
  "chunkSize": 900,
  "chunkOverlap": 120,
  "removeBoilerplate": true,
  "dedupeRepeatedLines": true,
  "includeReport": true
}
````

### Output Fields

Each dataset item represents one cleaned chunk:

- `chunkId`: Stable chunk identifier.
- `documentId`, `title`, `sourceUrl`: Source metadata.
- `chunkIndex`: Zero-based chunk index for that document.
- `chunkText`: Cleaned text ready for embedding or retrieval indexing.
- `charCount`, `wordCount`, `tokenEstimate`: Chunk size metrics.
- `status`: `ready`, `short`, or `empty`.
- `removedLineCount`, `duplicateLineCount`, `boilerplateLineCount`: Cleaning audit metrics.
- `issues`: Structured warnings or errors.
- `recommendation`: Short next step.

The key-value store also contains:

- `CLEANED_TEXT.md`: Cleaned Markdown grouped by document.
- `RAG_CHUNKS.json`: Full chunk array.
- `TEXT_CLEANER_REPORT.md`: Human-readable summary.
- `TEXT_CLEANER_SUMMARY.json`: Machine-readable summary.

### Cost-Control Tips

- Start with one or two documents and default chunk settings.
- Keep `maxDocuments` low until cleaning rules are confirmed.
- Larger `chunkSize` usually emits fewer chunks.
- Turn reports off only when you do not need cleaned Markdown or chunk JSON artifacts.

### FAQ

#### Does this fetch URLs?

No. Provide the text or HTML content directly. This avoids crawler cost and keeps tests deterministic.

#### Does this embed chunks?

No. It prepares chunks for downstream embeddings, vector stores, or RAG pipelines.

#### Can I keep boilerplate?

Yes. Set `removeBoilerplate` to `false`.

### Troubleshooting

- Empty output: check whether the source only contains boilerplate or scripts/styles.
- Too many short chunks: increase `chunkSize` or lower `minChunkChars`.
- Important repeated text removed: set `dedupeRepeatedLines` to `false`.
- Markdown links look wrong: try `stripMarkdownLinks`.

### Limitations

- Boilerplate detection is pattern-based, not ML-based.
- Chunking is character-oriented with paragraph awareness, not model-token exact.
- HTML extraction is intentionally simple and deterministic.

### Source And Safety Notes

This actor processes user-provided text and HTML. Only upload text you are authorized to process in Apify and downstream systems.

### Changelog

- `1.0.0`: Initial production build with HTML stripping, boilerplate and duplicate-line cleanup, chunk generation, PPE billing, examples, and fixture tests.

# Actor input Schema

## `documents` (type: `array`):

Document objects with text or HTML content.

## `text` (type: `string`):

Optional plain text document to clean.

## `html` (type: `string`):

Optional HTML document to strip and clean.

## `chunkSize` (type: `integer`):

Target maximum characters per output chunk.

## `chunkOverlap` (type: `integer`):

Approximate character overlap between adjacent chunks.

## `minChunkChars` (type: `integer`):

Minimum useful chunk length unless the document is shorter.

## `removeBoilerplate` (type: `boolean`):

Remove common web boilerplate such as cookie, newsletter, social, and navigation lines.

## `dedupeRepeatedLines` (type: `boolean`):

Drop repeated normalized lines inside each document.

## `stripMarkdownLinks` (type: `boolean`):

Convert markdown links to visible text.

## `preserveHeadings` (type: `boolean`):

Keep markdown heading markers for downstream retrieval context.

## `maxDocuments` (type: `integer`):

Maximum documents to process.

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

Maximum cleaned chunks emitted across all documents.

## `maxTextBytes` (type: `integer`):

Maximum UTF-8 bytes cleaned from each document.

## `includeReport` (type: `boolean`):

Write cleaned markdown, chunks JSON, and summary reports to the key-value store.

## `dryRun` (type: `boolean`):

Validate input and write a dry-run summary without PPE charges or dataset output.

## `debug` (type: `boolean`):

Enable debug logs.

## Actor input object example

```json
{
  "text": "Cookie settings\\nSubscribe to our newsletter\\n# Product Documentation\\nThis guide explains how to configure the API for production workloads.\\nThis guide explains how to configure the API for production workloads.\\nContact sales\\nUse retries, idempotency keys, and structured logs when integrating.",
  "chunkSize": 900,
  "chunkOverlap": 120,
  "minChunkChars": 80,
  "removeBoilerplate": true,
  "dedupeRepeatedLines": true,
  "stripMarkdownLinks": false,
  "preserveHeadings": true,
  "maxDocuments": 25,
  "maxItems": 100,
  "maxTextBytes": 1000000,
  "includeReport": true,
  "dryRun": false,
  "debug": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Structured cleaned text chunks for retrieval workflows.

## `summary` (type: `string`):

Run summary artifact stored in the default key-value store.

# 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 = {
    "text": "Cookie settings\\nSubscribe to our newsletter\\n# Product Documentation\\nThis guide explains how to configure the API for production workloads.\\nThis guide explains how to configure the API for production workloads.\\nContact sales\\nUse retries, idempotency keys, and structured logs when integrating."
};

// Run the Actor and wait for it to finish
const run = await client.actor("junipr/text-cleaner-for-rag").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 = { "text": "Cookie settings\\nSubscribe to our newsletter\\n# Product Documentation\\nThis guide explains how to configure the API for production workloads.\\nThis guide explains how to configure the API for production workloads.\\nContact sales\\nUse retries, idempotency keys, and structured logs when integrating." }

# Run the Actor and wait for it to finish
run = client.actor("junipr/text-cleaner-for-rag").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 '{
  "text": "Cookie settings\\\\nSubscribe to our newsletter\\\\n# Product Documentation\\\\nThis guide explains how to configure the API for production workloads.\\\\nThis guide explains how to configure the API for production workloads.\\\\nContact sales\\\\nUse retries, idempotency keys, and structured logs when integrating."
}' |
apify call junipr/text-cleaner-for-rag --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=junipr/text-cleaner-for-rag",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Text Cleaner For RAG",
        "description": "Clean web text for RAG by removing boilerplate, normalizing whitespace, and producing chunk-ready text.",
        "version": "1.0",
        "x-build-id": "P2BFY1e3cLcOeoxij"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/junipr~text-cleaner-for-rag/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-junipr-text-cleaner-for-rag",
                "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/junipr~text-cleaner-for-rag/runs": {
            "post": {
                "operationId": "runs-sync-junipr-text-cleaner-for-rag",
                "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/junipr~text-cleaner-for-rag/run-sync": {
            "post": {
                "operationId": "run-sync-junipr-text-cleaner-for-rag",
                "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": {
                    "documents": {
                        "title": "Documents",
                        "type": "array",
                        "description": "Document objects with text or HTML content.",
                        "items": {
                            "type": "object"
                        }
                    },
                    "text": {
                        "title": "Single Text Document",
                        "type": "string",
                        "description": "Optional plain text document to clean."
                    },
                    "html": {
                        "title": "Single HTML Document",
                        "type": "string",
                        "description": "Optional HTML document to strip and clean."
                    },
                    "chunkSize": {
                        "title": "Chunk Size",
                        "minimum": 200,
                        "maximum": 4000,
                        "type": "integer",
                        "description": "Target maximum characters per output chunk.",
                        "default": 900
                    },
                    "chunkOverlap": {
                        "title": "Chunk Overlap",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Approximate character overlap between adjacent chunks.",
                        "default": 120
                    },
                    "minChunkChars": {
                        "title": "Minimum Chunk Characters",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Minimum useful chunk length unless the document is shorter.",
                        "default": 80
                    },
                    "removeBoilerplate": {
                        "title": "Remove Boilerplate",
                        "type": "boolean",
                        "description": "Remove common web boilerplate such as cookie, newsletter, social, and navigation lines.",
                        "default": true
                    },
                    "dedupeRepeatedLines": {
                        "title": "Deduplicate Repeated Lines",
                        "type": "boolean",
                        "description": "Drop repeated normalized lines inside each document.",
                        "default": true
                    },
                    "stripMarkdownLinks": {
                        "title": "Strip Markdown Links",
                        "type": "boolean",
                        "description": "Convert markdown links to visible text.",
                        "default": false
                    },
                    "preserveHeadings": {
                        "title": "Preserve Headings",
                        "type": "boolean",
                        "description": "Keep markdown heading markers for downstream retrieval context.",
                        "default": true
                    },
                    "maxDocuments": {
                        "title": "Max Documents",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum documents to process.",
                        "default": 25
                    },
                    "maxItems": {
                        "title": "Maximum Output Chunks",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum cleaned chunks emitted across all documents.",
                        "default": 100
                    },
                    "maxTextBytes": {
                        "title": "Maximum Bytes Per Document",
                        "minimum": 1000,
                        "maximum": 5000000,
                        "type": "integer",
                        "description": "Maximum UTF-8 bytes cleaned from each document.",
                        "default": 1000000
                    },
                    "includeReport": {
                        "title": "Include Report Artifacts",
                        "type": "boolean",
                        "description": "Write cleaned markdown, chunks JSON, and summary reports to the key-value store.",
                        "default": true
                    },
                    "dryRun": {
                        "title": "Dry Run",
                        "type": "boolean",
                        "description": "Validate input and write a dry-run summary without PPE charges or dataset output.",
                        "default": false
                    },
                    "debug": {
                        "title": "Debug Logs",
                        "type": "boolean",
                        "description": "Enable debug logs.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```