# Text Chunker: Split Text & Documents into Chunks for RAG (`raional/text-chunker`) Actor Split long text or documents into properly sized, sentence-aware chunks with overlap for embeddings, vector databases, and RAG pipelines. Choose recursive, sentence-boundary, or fixed-token chunking. Fetch from URLs or paste text directly. Powered by Chonkie. - **URL**: https://apify.com/raional/text-chunker.md - **Developed by:** [Raion Al](https://apify.com/raional) (community) - **Categories:** AI, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing $0.50 / 1,000 chunks 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. 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/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Chunker: Split Text & Documents into Chunks for RAG and Embeddings **Split long text or documents into properly sized, boundary-aware chunks with overlap**, ready to embed into a vector database. Choose recursive (structure-aware), sentence-safe, or fixed-token-window chunking, each with configurable size and overlap. Powered by [Chonkie](https://github.com/feyninc/chonkie) (MIT licensed, 4,500+ GitHub stars), an open-source chunking library. Chunk sizes are counted in real BPE tokens (the same style of tokenizer used by common LLMs), not raw characters, so a "512-token chunk" means what it says. Great for: **text chunker**, **chunk text for embeddings**, **RAG chunking tool**, **split text into chunks**, **text splitter for LLM**, feeding a vector database (Pinecone, Qdrant, Weaviate, Chroma, pgvector...), building a RAG pipeline, and preparing knowledge-base articles or converted documents for an AI chatbot. ### What it does Give it text directly, or a list of URLs to plain-text/Markdown files (for example, the Markdown output of a PDF-to-Markdown converter). It splits each one into chunks sized and overlapped the way you configure, and returns one row per chunk with its token count and position in the source document. Nothing is stored beyond the run. ### Chunking strategies | `chunkingStrategy` | What it does | |---|---| | `recursive` (default) | Smart general-purpose default. Splits on paragraph breaks first, then sentences, then words, packing as much as fits into each chunk. Best balance of clean boundaries and consistent chunk size. | | `sentence` | Never splits a sentence in half. Packs whole sentences up to the size limit, even if that means a chunk runs a little over when a single sentence is long. Best when exact sentence integrity matters more than exact chunk size. | | `token` | Fastest option. Fixed-size sliding token windows with no awareness of sentence or word boundaries, may cut mid-word. Best when you need a strict, predictable token budget (e.g. to exactly match an embedding model's limit). | All three strategies support overlap: a run of tokens repeated at the boundary between consecutive chunks, so an idea split across a chunk boundary still appears whole in at least one chunk. ### Example input ```json { "texts": [ "Paste one or more long pieces of text here..." ], "documentUrls": [ "https://example.com/knowledge-base-article.md" ], "chunkingStrategy": "recursive", "chunkSize": 512, "chunkOverlap": 50 } ```` ### Output One row per chunk: | Field | Description | |---|---| | `source` | Which input this chunk came from (`Text #1`, or the document URL) | | `sourceType` | `text` or `url` | | `chunkIndex` / `totalChunks` | This chunk's position and the total chunk count for its source | | `text` | The chunk's text: the payload to embed | | `tokenCount` | Token count of this chunk | | `characterCount` | Character count of this chunk | | `startIndex` / `endIndex` | Character offsets into the original source text, for citation/traceability | | `status` | `ok`, `empty` (blank input), or `error` | ### Pricing Billed **per chunk produced**, plus a small flat per-run fee. Failed or empty inputs are **not charged**. ### FAQ **How do I chunk text for a RAG pipeline?** Paste your text into `texts` (or point `documentUrls` at a hosted `.txt`/`.md` file) and run. Each output row is one chunk, ready to embed and upsert into your vector database. **What chunk size should I use?** 512 tokens with 50 tokens of overlap is a reasonable default for most embedding models. Use smaller chunks (128–256 tokens) for precise retrieval over short facts, or larger chunks (1000+ tokens) when matches need more surrounding context. **Why is chunk size measured in tokens, not characters?** Embedding models and LLMs have context limits measured in tokens, not characters, and one token is roughly 4 characters of English text but varies by content. Sizing chunks in real tokens means they actually fit the budget you're planning for. **Does this cut sentences in half?** Only the `token` strategy does, by design, for a strict fixed-size window. `sentence` never does. `recursive` respects sentence and paragraph boundaries for the main chunk split; only its overlap region can include a few tokens of the next chunk's opening as extra context. **Can I chunk the output of a PDF-to-Markdown converter?** Yes. Run your PDF through a document-to-Markdown actor, then feed the resulting Markdown URL (or pasted text) into `documentUrls` or `texts` here. **Does this call any AI model or send my text anywhere for processing?** No. Chunking is deterministic and local to the run: no embedding model, no LLM, no external API calls other than fetching a URL you provide. ### Please note Only chunk text/documents you have the right to process. Input is processed transiently and not retained beyond the run. Built with [Apify Python SDK](https://docs.apify.com/sdk/python/) + [Chonkie](https://github.com/feyninc/chonkie). # Actor input Schema ## `texts` (type: `array`): One or more pieces of text to split into chunks. Each entry is chunked independently. Leave empty if you're only using Document URLs below. ## `documentUrls` (type: `array`): URLs of plain-text or Markdown files to fetch and chunk (for example, Markdown output from a PDF-to-Markdown converter). Combines with any text listed above. ## `chunkingStrategy` (type: `string`): Recursive = smart default; splits on paragraph, sentence, then word boundaries to best fit the size (recommended for most documents). Sentence = never splits mid-sentence, always keeps whole sentences together. Token = fastest, fixed-size token windows; may split mid-sentence. ## `chunkSize` (type: `integer`): Target maximum number of tokens per chunk. 512 is a good default for most embedding models; use smaller chunks for precise retrieval or larger chunks for more context per match. ## `chunkOverlap` (type: `integer`): Number of tokens repeated between consecutive chunks, so an idea split across a chunk boundary still appears whole in at least one chunk. Set to 0 for no overlap. ## Actor input object example ```json { "texts": [ "Our platform lets you connect a data source, transform records with a visual pipeline builder, and publish the result to any destination without writing code. Most teams get their first pipeline running within an afternoon, and support is available by chat if you get stuck along the way.\n\nConnections are managed centrally. Once you authorize a data source, every pipeline in your workspace can reuse that connection, so credentials are entered once and rotated in a single place. We support more than sixty destinations, including data warehouses, spreadsheets, and webhooks, and new destinations are added every month based on customer requests submitted through the roadmap board.\n\nPipelines run on a schedule you define, from every five minutes to once a month, or you can trigger a run manually from the dashboard or through the API. Each run produces a detailed log you can inspect later, and failed runs send an alert to the channel you configure, whether that is email, Slack, or a custom webhook endpoint of your choosing.\n\nHistorical run data is retained for ninety days on paid plans and seven days on the free plan. You can export any run's input and output as JSON at any time, which is useful for debugging a transform step or for feeding results into another system entirely.\n\nRole-based access control lets you decide who can view, edit, or run each pipeline. Workspace owners can invite teammates by email, assign them to one of four roles, and restrict sensitive connections to a specific team. Audit logs record every permission change so you always know who altered access and when.\n\nPricing is usage-based and scales with the number of records processed each month rather than the number of pipelines or seats, so you can add as many teammates and workflows as you like without the bill changing. A free plan covers light usage and is a good way to evaluate the product before committing to a paid tier. Enterprise customers can request a fixed-price contract with a dedicated support engineer and a custom data retention window.\n\nThe underlying engine retries failed steps automatically using exponential backoff, and it de-duplicates records so a retried run never writes the same row twice to your destination. If a destination is temporarily unreachable, pending records queue safely and resume delivery once the destination comes back online, so a brief outage downstream does not require you to manually replay anything.\n\nMonitoring is built into every workspace. A live status page shows the health of each pipeline, the average run duration over the last thirty days, and the volume of records processed per hour. You can set custom thresholds so an alert fires before a slow pipeline turns into a missed deadline, rather than only after something has already broken downstream.\n\nMigrating from another tool is usually the first thing new customers ask about. Our import wizard reads an existing pipeline configuration from several competing tools and recreates the equivalent steps automatically, flagging anything it could not translate so you can finish those by hand. Most migrations of a few dozen pipelines are completed within a single working day, including validation against a sample of real production data." ], "chunkingStrategy": "recursive", "chunkSize": 512, "chunkOverlap": 50 } ``` # Actor output Schema ## `chunks` (type: `string`): One dataset row per chunk: source, chunkIndex, totalChunks, text, tokenCount, characterCount, startIndex, endIndex, status. ## `summary` (type: `string`): Counts of documents processed, chunks produced, and errors. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "texts": [ "Our platform lets you connect a data source, transform records with a visual pipeline builder, and publish the result to any destination without writing code. Most teams get their first pipeline running within an afternoon, and support is available by chat if you get stuck along the way.\n\nConnections are managed centrally. Once you authorize a data source, every pipeline in your workspace can reuse that connection, so credentials are entered once and rotated in a single place. We support more than sixty destinations, including data warehouses, spreadsheets, and webhooks, and new destinations are added every month based on customer requests submitted through the roadmap board.\n\nPipelines run on a schedule you define, from every five minutes to once a month, or you can trigger a run manually from the dashboard or through the API. Each run produces a detailed log you can inspect later, and failed runs send an alert to the channel you configure, whether that is email, Slack, or a custom webhook endpoint of your choosing.\n\nHistorical run data is retained for ninety days on paid plans and seven days on the free plan. You can export any run's input and output as JSON at any time, which is useful for debugging a transform step or for feeding results into another system entirely.\n\nRole-based access control lets you decide who can view, edit, or run each pipeline. Workspace owners can invite teammates by email, assign them to one of four roles, and restrict sensitive connections to a specific team. Audit logs record every permission change so you always know who altered access and when.\n\nPricing is usage-based and scales with the number of records processed each month rather than the number of pipelines or seats, so you can add as many teammates and workflows as you like without the bill changing. A free plan covers light usage and is a good way to evaluate the product before committing to a paid tier. Enterprise customers can request a fixed-price contract with a dedicated support engineer and a custom data retention window.\n\nThe underlying engine retries failed steps automatically using exponential backoff, and it de-duplicates records so a retried run never writes the same row twice to your destination. If a destination is temporarily unreachable, pending records queue safely and resume delivery once the destination comes back online, so a brief outage downstream does not require you to manually replay anything.\n\nMonitoring is built into every workspace. A live status page shows the health of each pipeline, the average run duration over the last thirty days, and the volume of records processed per hour. You can set custom thresholds so an alert fires before a slow pipeline turns into a missed deadline, rather than only after something has already broken downstream.\n\nMigrating from another tool is usually the first thing new customers ask about. Our import wizard reads an existing pipeline configuration from several competing tools and recreates the equivalent steps automatically, flagging anything it could not translate so you can finish those by hand. Most migrations of a few dozen pipelines are completed within a single working day, including validation against a sample of real production data." ] }; // Run the Actor and wait for it to finish const run = await client.actor("raional/text-chunker").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "texts": ["""Our platform lets you connect a data source, transform records with a visual pipeline builder, and publish the result to any destination without writing code. Most teams get their first pipeline running within an afternoon, and support is available by chat if you get stuck along the way. Connections are managed centrally. Once you authorize a data source, every pipeline in your workspace can reuse that connection, so credentials are entered once and rotated in a single place. We support more than sixty destinations, including data warehouses, spreadsheets, and webhooks, and new destinations are added every month based on customer requests submitted through the roadmap board. Pipelines run on a schedule you define, from every five minutes to once a month, or you can trigger a run manually from the dashboard or through the API. Each run produces a detailed log you can inspect later, and failed runs send an alert to the channel you configure, whether that is email, Slack, or a custom webhook endpoint of your choosing. Historical run data is retained for ninety days on paid plans and seven days on the free plan. You can export any run's input and output as JSON at any time, which is useful for debugging a transform step or for feeding results into another system entirely. Role-based access control lets you decide who can view, edit, or run each pipeline. Workspace owners can invite teammates by email, assign them to one of four roles, and restrict sensitive connections to a specific team. Audit logs record every permission change so you always know who altered access and when. Pricing is usage-based and scales with the number of records processed each month rather than the number of pipelines or seats, so you can add as many teammates and workflows as you like without the bill changing. A free plan covers light usage and is a good way to evaluate the product before committing to a paid tier. Enterprise customers can request a fixed-price contract with a dedicated support engineer and a custom data retention window. The underlying engine retries failed steps automatically using exponential backoff, and it de-duplicates records so a retried run never writes the same row twice to your destination. If a destination is temporarily unreachable, pending records queue safely and resume delivery once the destination comes back online, so a brief outage downstream does not require you to manually replay anything. Monitoring is built into every workspace. A live status page shows the health of each pipeline, the average run duration over the last thirty days, and the volume of records processed per hour. You can set custom thresholds so an alert fires before a slow pipeline turns into a missed deadline, rather than only after something has already broken downstream. Migrating from another tool is usually the first thing new customers ask about. Our import wizard reads an existing pipeline configuration from several competing tools and recreates the equivalent steps automatically, flagging anything it could not translate so you can finish those by hand. Most migrations of a few dozen pipelines are completed within a single working day, including validation against a sample of real production data."""] } # Run the Actor and wait for it to finish run = client.actor("raional/text-chunker").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": [ "Our platform lets you connect a data source, transform records with a visual pipeline builder, and publish the result to any destination without writing code. Most teams get their first pipeline running within an afternoon, and support is available by chat if you get stuck along the way.\\n\\nConnections are managed centrally. Once you authorize a data source, every pipeline in your workspace can reuse that connection, so credentials are entered once and rotated in a single place. We support more than sixty destinations, including data warehouses, spreadsheets, and webhooks, and new destinations are added every month based on customer requests submitted through the roadmap board.\\n\\nPipelines run on a schedule you define, from every five minutes to once a month, or you can trigger a run manually from the dashboard or through the API. Each run produces a detailed log you can inspect later, and failed runs send an alert to the channel you configure, whether that is email, Slack, or a custom webhook endpoint of your choosing.\\n\\nHistorical run data is retained for ninety days on paid plans and seven days on the free plan. You can export any run'\''s input and output as JSON at any time, which is useful for debugging a transform step or for feeding results into another system entirely.\\n\\nRole-based access control lets you decide who can view, edit, or run each pipeline. Workspace owners can invite teammates by email, assign them to one of four roles, and restrict sensitive connections to a specific team. Audit logs record every permission change so you always know who altered access and when.\\n\\nPricing is usage-based and scales with the number of records processed each month rather than the number of pipelines or seats, so you can add as many teammates and workflows as you like without the bill changing. A free plan covers light usage and is a good way to evaluate the product before committing to a paid tier. Enterprise customers can request a fixed-price contract with a dedicated support engineer and a custom data retention window.\\n\\nThe underlying engine retries failed steps automatically using exponential backoff, and it de-duplicates records so a retried run never writes the same row twice to your destination. If a destination is temporarily unreachable, pending records queue safely and resume delivery once the destination comes back online, so a brief outage downstream does not require you to manually replay anything.\\n\\nMonitoring is built into every workspace. A live status page shows the health of each pipeline, the average run duration over the last thirty days, and the volume of records processed per hour. You can set custom thresholds so an alert fires before a slow pipeline turns into a missed deadline, rather than only after something has already broken downstream.\\n\\nMigrating from another tool is usually the first thing new customers ask about. Our import wizard reads an existing pipeline configuration from several competing tools and recreates the equivalent steps automatically, flagging anything it could not translate so you can finish those by hand. Most migrations of a few dozen pipelines are completed within a single working day, including validation against a sample of real production data." ] }' | apify call raional/text-chunker --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=raional/text-chunker", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Text Chunker: Split Text & Documents into Chunks for RAG", "description": "Split long text or documents into properly sized, sentence-aware chunks with overlap for embeddings, vector databases, and RAG pipelines. Choose recursive, sentence-boundary, or fixed-token chunking. Fetch from URLs or paste text directly. Powered by Chonkie.", "version": "0.1", "x-build-id": "HRT8fPGwNHiHnDmWn" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/raional~text-chunker/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-raional-text-chunker", "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/raional~text-chunker/runs": { "post": { "operationId": "runs-sync-raional-text-chunker", "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/raional~text-chunker/run-sync": { "post": { "operationId": "run-sync-raional-text-chunker", "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": { "texts": { "title": "Text to chunk", "type": "array", "description": "One or more pieces of text to split into chunks. Each entry is chunked independently. Leave empty if you're only using Document URLs below.", "items": { "type": "string" } }, "documentUrls": { "title": "Or fetch documents from URLs", "type": "array", "description": "URLs of plain-text or Markdown files to fetch and chunk (for example, Markdown output from a PDF-to-Markdown converter). Combines with any text listed above.", "items": { "type": "string" } }, "chunkingStrategy": { "title": "Chunking strategy", "enum": [ "recursive", "sentence", "token" ], "type": "string", "description": "Recursive = smart default; splits on paragraph, sentence, then word boundaries to best fit the size (recommended for most documents). Sentence = never splits mid-sentence, always keeps whole sentences together. Token = fastest, fixed-size token windows; may split mid-sentence.", "default": "recursive" }, "chunkSize": { "title": "Chunk size (tokens)", "minimum": 50, "maximum": 8192, "type": "integer", "description": "Target maximum number of tokens per chunk. 512 is a good default for most embedding models; use smaller chunks for precise retrieval or larger chunks for more context per match.", "default": 512 }, "chunkOverlap": { "title": "Chunk overlap (tokens)", "minimum": 0, "maximum": 2048, "type": "integer", "description": "Number of tokens repeated between consecutive chunks, so an idea split across a chunk boundary still appears whole in at least one chunk. Set to 0 for no overlap.", "default": 50 } } }, "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 } } } } } } } } } } ```