# Profanity Checker (`maximedupre/profanity-checker`) Actor

Check comments, reviews, messages, and text snippets for blocked words. Clean text and export match evidence for content moderation workflows.

- **URL**: https://apify.com/maximedupre/profanity-checker.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.25 / 1,000 processed texts

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

### 🛡️ Profanity checker for moderation workflows

Profanity Checker helps you check comments, reviews, messages, survey answers, support tickets, and other text snippets for blocked words. Paste one text or a batch of texts, add optional custom blocked words or allowed words, and get one clean dataset row per processed text with the original text, cleaned text, match evidence, counts, and a timestamp.

Use it when you need a fast profanity checker before sending text into a CRM, help desk, review queue, chatbot, community tool, analytics pipeline, or spreadsheet. The Actor is deterministic, so the same input and word settings produce the same output. It does not need a login, cookies, API key, or source website.

For a small first run, keep the prefilled examples and run the Actor. You will see how built-in blocked words, custom words, allowed words, and replacement modes appear in the output before you connect a larger workflow through the Apify API, schedules, webhooks, or dataset exports.

### ✅ What this profanity checker does

- Checks each submitted text snippet against a built-in English blocked-word list.
- Lets you add extra custom blocked words for your product, brand, community, or internal policy.
- Lets you allow words that would otherwise be blocked.
- Supports mask, replacement text, and removal modes.
- Returns cleaned text while preserving the original text for review.
- Includes match evidence with positions, matched text, canonical term, source list, and replacement value.
- Saves one dataset row per processed text.
- Charges only for processed text rows.

Custom blocked words are extra words on top of the default list. Allowed words subtract from both the default list and your custom list, which is useful for brand names, usernames, product names, quoted content, or terms that are acceptable in your own workflow.

### 📊 Data you get

Each output row represents one processed text snippet. Rows include:

| Field | Description |
| --- | --- |
| `inputIndex` | 1-based position of the submitted text. |
| `originalText` | Text exactly as submitted. |
| `cleanedText` | Text after the selected replacement mode is applied. |
| `containsProfanity` | Whether any blocked words were found after allowed words were applied. |
| `matchCount` | Number of blocked-word matches found. |
| `replacementCount` | Number of replacements applied to the cleaned text. |
| `matches` | Match evidence with text, canonical term, list source, character positions, replacement value, and allowed status. |
| `listVersion` | Built-in list version used for the run. |
| `processedAt` | UTC timestamp when the text was processed. |

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML, or use the output through the Apify API and integrations.

### 🚀 How to run it

1. Open the Actor input.
2. Add one or more items in **Text snippets**.
3. Add **Custom blocked words** if your workflow needs extra terms.
4. Add **Allowed words** for terms that should pass even if they appear in the default or custom list.
5. Choose **Replacement mode**.
6. Start the Actor and open the dataset.

Use `Mask blocked words` when you want readable cleaned text with the same rough shape as the original. Use `Replace with custom text` when downstream tools expect a fixed marker such as `[redacted]`. Use `Remove blocked words` when you want the term deleted from the cleaned text.

### 🧾 Input example

```json
{
	"texts": [
		"This review is clean and ready to publish.",
		"Please redact this damn message before export."
	],
	"customWords": ["spoiler"],
	"allowedWords": ["damnation"],
	"replacementMode": "mask",
	"replacementText": "*"
}
````

`Text snippets` is the only required input. Custom blocked words and allowed words are optional. The default replacement mode is masking.

### 📤 Output example

```json
{
	"inputIndex": 2,
	"originalText": "Please redact this damn message before export.",
	"cleanedText": "Please redact this **** message before export.",
	"containsProfanity": true,
	"matchCount": 1,
	"replacementCount": 1,
	"matches": [
		{
			"matchedText": "damn",
			"canonicalTerm": "damn",
			"source": "builtin",
			"start": 19,
			"end": 23,
			"replacement": "****",
			"allowed": false
		}
	],
	"listVersion": "builtin-en-v1",
	"processedAt": "2026-06-15T12:00:00.000Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged once per text snippet processed.

Current event price:

| Unit | Price |
| --- | ---: |
| Processed text | `$0.00025` |

That equals `$0.25` per 1,000 processed text snippets. There is no separate Actor-start charge in this Actor's local pricing artifact.

### ⚠️ Limits and caveats

Profanity Checker is a blocked-word checker, not a toxicity classifier, sentiment model, legal review tool, or full trust-and-safety system. It finds terms from the built-in list plus your custom words, then applies your allowed-word exceptions.

The Actor does not understand intent, sarcasm, harassment severity, language context, image content, audio, or user history. It is best used as a deterministic text-cleaning step, a moderation signal, or a prefilter before human review or a richer policy workflow.

The built-in list is English-focused. For brand-specific, community-specific, or multilingual rules, add custom blocked words and allowed words that match your own policy.

### ❓ FAQ

#### ➕ Are custom blocked words added to the default list?

Yes. Custom blocked words are extra words on top of the default built-in list.

#### ✅ What do allowed words do?

Allowed words override both the built-in list and custom blocked words. Use them for terms that should pass in your workflow.

#### 🔐 Do I need an API key or account login?

No. This Actor checks the text you provide. It does not connect to an external content platform.

#### 🧠 Is this an AI moderation classifier?

No. It is a deterministic blocked-word checker with match evidence and cleaned text output. It does not assign toxicity scores or infer intent.

#### 📁 Can I use it with CSV or spreadsheets?

Yes. Pass text snippets through the Apify Console, API, integrations, or your own workflow, then export the dataset to CSV, Excel, JSON, and other supported formats.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

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

### 🔗 Other actors

- [Webpage Text Extractor ↗](https://apify.com/maximedupre/webpage-text-extractor) - Extract clean page text or Markdown before moderation or LLM workflows.
- [Email MX Verifier ↗](https://apify.com/maximedupre/email-mx-verifier) - Check email syntax, MX records, disposable domains, and delivery risk.
- [SMTP Email Verifier ↗](https://apify.com/maximedupre/smtp-email-verifier) - Probe mailbox deliverability with SMTP evidence before outreach.
- [Website Emails Scraper ↗](https://apify.com/maximedupre/website-emails-scraper) - Find public contact emails from websites for lead or data workflows.
- [Gmail Username Checker ↗](https://apify.com/maximedupre/gmail-username-checker) - Check Gmail username availability for new address ideas.

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

# Actor input Schema

## `texts` (type: `array`):

Paste the text snippets you want checked. Each item returns one processed row.

## `customWords` (type: `array`):

Add exact words or short phrases that should be treated as blocked terms for this run.

## `allowedWords` (type: `array`):

Add exact words or phrases that should stay unchanged when they match a safe term.

## `replacementMode` (type: `string`):

Choose how blocked terms appear in the cleaned text.

## `replacementText` (type: `string`):

Use one character for masking, or a short phrase when replacement mode is set to text.

## Actor input object example

```json
{
  "texts": [
    "Default QA 1: please hide this shit before export.",
    "Default QA 2: clean text without blocked words.",
    "Default QA 3: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 4: clean text without blocked words.",
    "Default QA 5: spoiler should be caught by custom words.",
    "Default QA 6: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 7: please hide this shit before export.",
    "Default QA 8: clean text without blocked words.",
    "Default QA 9: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 10: spoiler should be caught by custom words.",
    "Default QA 11: please hide this shit before export.",
    "Default QA 12: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 13: please hide this shit before export.",
    "Default QA 14: clean text without blocked words.",
    "Default QA 15: spoiler should be caught by custom words.",
    "Default QA 16: clean text without blocked words.",
    "Default QA 17: please hide this shit before export.",
    "Default QA 18: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 19: please hide this shit before export.",
    "Default QA 20: spoiler should be caught by custom words.",
    "Default QA 21: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 22: clean text without blocked words.",
    "Default QA 23: please hide this shit before export.",
    "Default QA 24: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 25: spoiler should be caught by custom words."
  ],
  "customWords": [
    "spoiler"
  ],
  "allowedWords": [
    "damnation"
  ],
  "replacementMode": "mask",
  "replacementText": "*"
}
```

# Actor output Schema

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

Open the dataset with profanity checker results.

# 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 = {
    "texts": [
        "Default QA 1: please hide this shit before export.",
        "Default QA 2: clean text without blocked words.",
        "Default QA 3: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 4: clean text without blocked words.",
        "Default QA 5: spoiler should be caught by custom words.",
        "Default QA 6: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 7: please hide this shit before export.",
        "Default QA 8: clean text without blocked words.",
        "Default QA 9: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 10: spoiler should be caught by custom words.",
        "Default QA 11: please hide this shit before export.",
        "Default QA 12: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 13: please hide this shit before export.",
        "Default QA 14: clean text without blocked words.",
        "Default QA 15: spoiler should be caught by custom words.",
        "Default QA 16: clean text without blocked words.",
        "Default QA 17: please hide this shit before export.",
        "Default QA 18: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 19: please hide this shit before export.",
        "Default QA 20: spoiler should be caught by custom words.",
        "Default QA 21: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 22: clean text without blocked words.",
        "Default QA 23: please hide this shit before export.",
        "Default QA 24: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 25: spoiler should be caught by custom words."
    ],
    "customWords": [
        "spoiler"
    ],
    "allowedWords": [
        "damnation"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/profanity-checker").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 = {
    "texts": [
        "Default QA 1: please hide this shit before export.",
        "Default QA 2: clean text without blocked words.",
        "Default QA 3: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 4: clean text without blocked words.",
        "Default QA 5: spoiler should be caught by custom words.",
        "Default QA 6: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 7: please hide this shit before export.",
        "Default QA 8: clean text without blocked words.",
        "Default QA 9: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 10: spoiler should be caught by custom words.",
        "Default QA 11: please hide this shit before export.",
        "Default QA 12: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 13: please hide this shit before export.",
        "Default QA 14: clean text without blocked words.",
        "Default QA 15: spoiler should be caught by custom words.",
        "Default QA 16: clean text without blocked words.",
        "Default QA 17: please hide this shit before export.",
        "Default QA 18: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 19: please hide this shit before export.",
        "Default QA 20: spoiler should be caught by custom words.",
        "Default QA 21: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 22: clean text without blocked words.",
        "Default QA 23: please hide this shit before export.",
        "Default QA 24: this damn message is allowed to mask, but damnation stays safe.",
        "Default QA 25: spoiler should be caught by custom words.",
    ],
    "customWords": ["spoiler"],
    "allowedWords": ["damnation"],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/profanity-checker").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 '{
  "texts": [
    "Default QA 1: please hide this shit before export.",
    "Default QA 2: clean text without blocked words.",
    "Default QA 3: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 4: clean text without blocked words.",
    "Default QA 5: spoiler should be caught by custom words.",
    "Default QA 6: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 7: please hide this shit before export.",
    "Default QA 8: clean text without blocked words.",
    "Default QA 9: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 10: spoiler should be caught by custom words.",
    "Default QA 11: please hide this shit before export.",
    "Default QA 12: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 13: please hide this shit before export.",
    "Default QA 14: clean text without blocked words.",
    "Default QA 15: spoiler should be caught by custom words.",
    "Default QA 16: clean text without blocked words.",
    "Default QA 17: please hide this shit before export.",
    "Default QA 18: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 19: please hide this shit before export.",
    "Default QA 20: spoiler should be caught by custom words.",
    "Default QA 21: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 22: clean text without blocked words.",
    "Default QA 23: please hide this shit before export.",
    "Default QA 24: this damn message is allowed to mask, but damnation stays safe.",
    "Default QA 25: spoiler should be caught by custom words."
  ],
  "customWords": [
    "spoiler"
  ],
  "allowedWords": [
    "damnation"
  ]
}' |
apify call maximedupre/profanity-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Profanity Checker",
        "description": "Check comments, reviews, messages, and text snippets for blocked words. Clean text and export match evidence for content moderation workflows.",
        "version": "0.1",
        "x-build-id": "asohtVjS1eJ2rZcvq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~profanity-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-profanity-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~profanity-checker/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-profanity-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~profanity-checker/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-profanity-checker",
                "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": [
                    "texts"
                ],
                "properties": {
                    "texts": {
                        "title": "Texts to check",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Paste the text snippets you want checked. Each item returns one processed row.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "customWords": {
                        "title": "Custom blocked words",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add exact words or short phrases that should be treated as blocked terms for this run.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 80
                        }
                    },
                    "allowedWords": {
                        "title": "Allowed words",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add exact words or phrases that should stay unchanged when they match a safe term.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 80
                        }
                    },
                    "replacementMode": {
                        "title": "Replacement mode",
                        "enum": [
                            "mask",
                            "text",
                            "remove"
                        ],
                        "type": "string",
                        "description": "Choose how blocked terms appear in the cleaned text.",
                        "default": "mask"
                    },
                    "replacementText": {
                        "title": "Replacement text or mask",
                        "maxLength": 40,
                        "type": "string",
                        "description": "Use one character for masking, or a short phrase when replacement mode is set to text.",
                        "default": "*"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
