# Python Scraper (`sovanza.inc/python-scraper`) Actor

Python Scraper extracts web page data using Requests and BeautifulSoup. It collects titles, meta tags, headings, links, images, Open Graph data, text snippets, and custom CSS selector fields, with exports to JSON, CSV, Excel, XML, or HTML.

- **URL**: https://apify.com/sovanza.inc/python-scraper.md
- **Developed by:** [Sovanza](https://apify.com/sovanza.inc) (community)
- **Categories:** Developer tools, SEO tools
- **Stats:** 12 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 1,000 scraped pages

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

## Python Scraper – Extract Web Page Data with Requests & BeautifulSoup

<p>
<strong>Python Scraper</strong> is a general-purpose Apify Actor that fetches public web pages with
<strong>Requests</strong>, parses HTML with <strong>BeautifulSoup</strong>, and returns structured metadata per URL.
Export combined results to <strong>JSON, CSV, Excel, XML, or HTML</strong> in the default key-value store.
</p>

<h2>Overview</h2>

<p>Each run processes your <code>startUrls</code> sequentially, pushes <strong>one dataset item per URL</strong>, and writes a combined export file named <code>{exportBasename}.{ext}</code>.</p>

<ul>
  <li><strong>No browser</strong> — fast for static HTML and simple sites</li>
  <li><strong>Custom CSS selectors</strong> — map field names to selectors without code changes</li>
  <li><strong>Secret inputs</strong> — cookies, bearer tokens, and request headers are encrypted in Apify storage</li>
  <li><strong>Automation-ready</strong> — API, schedules, and webhooks</li>
</ul>

<h2>Quick start</h2>

<ol>
  <li>Open <strong>Python Scraper</strong> on Apify and add one or more <strong>start URLs</strong> (e.g. <code>https://example.com</code>).</li>
  <li>Optionally set <strong>CSS selectors</strong> for extra fields and choose an <strong>export format</strong>.</li>
  <li>Click <strong>Run</strong> — inspect the <strong>Dataset</strong> tab for per-URL rows.</li>
  <li>Download the combined file from the run’s <strong>Key-value store</strong> (see Output schema links in Console).</li>
</ol>

<h3>Minimal input example</h3>

<pre><code class="language-json">{
  "startUrls": ["https://example.com"],
  "exportFormat": "json",
  "exportBasename": "EXPORT"
}</code></pre>

<h2>Input configuration</h2>

<table>
  <thead>
    <tr>
      <th>Field</th>
      <th>Required</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code>startUrls</code></td>
      <td>Yes</td>
      <td>URLs to scrape (string list).</td>
    </tr>
    <tr>
      <td><code>method</code></td>
      <td>No</td>
      <td><code>GET</code> or <code>POST</code> (default <code>GET</code>).</td>
    </tr>
    <tr>
      <td><code>cookies</code></td>
      <td>No</td>
      <td><strong>Secret.</strong> Raw <code>Cookie</code> header for logged-in sessions.</td>
    </tr>
    <tr>
      <td><code>bearerToken</code></td>
      <td>No</td>
      <td><strong>Secret.</strong> Bearer token sent as <code>Authorization</code> header.</td>
    </tr>
    <tr>
      <td><code>headers</code></td>
      <td>No</td>
      <td><strong>Secret.</strong> Extra HTTP headers (JSON object). Default User-Agent applied if omitted.</td>
    </tr>
    <tr>
      <td><code>timeoutSecs</code></td>
      <td>No</td>
      <td>Per-request timeout (default <code>60</code>, max <code>300</code>).</td>
    </tr>
    <tr>
      <td><code>selectors</code></td>
      <td>No</td>
      <td>Map of <code>fieldName → CSS selector</code> (supports <code>::text</code> suffix).</td>
    </tr>
    <tr>
      <td><code>includeLinks</code></td>
      <td>No</td>
      <td>Extract page links (default <code>true</code>).</td>
    </tr>
    <tr>
      <td><code>includeHtml</code></td>
      <td>No</td>
      <td>Include raw HTML in KV export only (default <code>false</code>; can be large).</td>
    </tr>
    <tr>
      <td><code>exportFormat</code></td>
      <td>No</td>
      <td><code>json</code>, <code>csv</code>, <code>excel</code>, <code>xml</code>, or <code>html</code>.</td>
    </tr>
    <tr>
      <td><code>exportBasename</code></td>
      <td>No</td>
      <td>KV export basename (default <code>EXPORT</code>); extension added automatically.</td>
    </tr>
  </tbody>
</table>

<h3>Full input example (with secrets and selectors)</h3>

<pre><code class="language-json">{
  "startUrls": [
    "https://example.com",
    "https://news.ycombinator.com/"
  ],
  "method": "GET",
  "cookies": "session=YOUR_SESSION; path=/",
  "bearerToken": "YOUR_API_TOKEN",
  "headers": {
    "Accept-Language": "en-US,en;q=0.9"
  },
  "timeoutSecs": 60,
  "selectors": {
    "headline": "h1::text",
    "tagline": "p.lead::text"
  },
  "includeLinks": true,
  "includeHtml": false,
  "exportFormat": "csv",
  "exportBasename": "EXPORT"
}</code></pre>

<p><em>Legacy input:</em> <code>exportKey</code> is still accepted at runtime but renamed to <code>exportBasename</code> in the schema.</p>

<h2>Output</h2>

<h3>Dataset (one row per URL)</h3>

<table>
  <thead>
    <tr>
      <th>Field</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr><td><code>url</code></td><td>Input URL</td></tr>
    <tr><td><code>finalUrl</code></td><td>URL after redirects</td></tr>
    <tr><td><code>status</code></td><td>HTTP status code</td></tr>
    <tr><td><code>title</code></td><td>Document title</td></tr>
    <tr><td><code>metaDescription</code></td><td>Meta description</td></tr>
    <tr><td><code>h1</code></td><td>Primary heading</td></tr>
    <tr><td><code>openGraph</code> / <code>twitterCard</code></td><td>Social meta objects</td></tr>
    <tr><td><code>links</code> / <code>linkCount</code></td><td>Extracted links when <code>includeLinks</code> is true</td></tr>
    <tr><td><code>error</code></td><td>Error message when a URL fails</td></tr>
    <tr><td><em>custom</em></td><td>Fields from your <code>selectors</code> map</td></tr>
  </tbody>
</table>

<h3>Example dataset item</h3>

<pre><code class="language-json">{
  "url": "https://example.com",
  "finalUrl": "https://example.com/",
  "status": 200,
  "title": "Example Domain",
  "metaDescription": "Example description",
  "h1": "Example Domain",
  "text": "This domain is for use in documentation examples...",
  "linkCount": 1,
  "contentType": "text/html"
}</code></pre>

<h3>Key-value store export</h3>

<p>Combined file: <code>{exportBasename}.json</code>, <code>.csv</code>, <code>.xlsx</code>, <code>.xml</code>, or <code>.html</code> depending on <code>exportFormat</code>. Use the actor <strong>Output</strong> schema in Console for direct API links.</p>

<h2>How it works</h2>

<ol>
  <li><strong>Requests</strong> fetches each URL with merged secret headers (cookies, bearer token, custom headers).</li>
  <li><strong>BeautifulSoup (lxml)</strong> parses HTML and extracts standard fields.</li>
  <li>Custom <strong>selectors</strong> run per configured field name.</li>
  <li>Each page is pushed to the <strong>default dataset</strong> (empty values omitted).</li>
  <li>All rows are serialized to the <strong>key-value store</strong> in the chosen format.</li>
</ol>

<h2>Authentication &amp; sensitive input</h2>

<p>Fields that can hold credentials use Apify <strong>secret input</strong> (<code>isSecret: true</code>):</p>

<ul>
  <li><code>cookies</code> — session cookies</li>
  <li><code>bearerToken</code> — API or OAuth bearer tokens</li>
  <li><code>headers</code> — JSON object for Authorization, API keys, or other sensitive headers</li>
</ul>

<p>Secret values are encrypted in storage and are <strong>not</strong> copied into dataset rows or logs.</p>

<h2>Best practices</h2>

<ul>
  <li>Respect <strong>robots.txt</strong>, site terms, and rate limits.</li>
  <li>Use realistic headers or cookies only when you are allowed to access the target pages.</li>
  <li>Increase <code>timeoutSecs</code> for slow sites.</li>
  <li>Keep <code>includeHtml</code> disabled unless you need raw HTML (large KV files).</li>
  <li>For JavaScript-heavy SPAs, use a Playwright-based actor instead.</li>
</ul>

<h2>Use cases</h2>

<ul>
  <li>SEO audits (title, meta, H1, canonical)</li>
  <li>Content monitoring with scheduled runs</li>
  <li>Directory or listing extraction with custom selectors</li>
  <li>Starter template for custom Python scrapers on Apify</li>
</ul>

<h2>Limitations</h2>

<ul>
  <li><strong>No JavaScript rendering</strong> — static HTML only.</li>
  <li><strong>Sequential requests</strong> — one URL at a time per run.</li>
  <li>No built-in Apify Proxy configuration in this actor (add headers/cookies or use platform proxy at account level if needed).</li>
</ul>

<h2>FAQ</h2>

<h3>Does this actor run JavaScript?</h3>
<p>No. It uses HTTP + HTML parsing. Dynamic sites may need Playwright or Puppeteer.</p>

<h3>How do custom CSS selectors work?</h3>
<p>Add a JSON object <code>selectors</code> where keys are output field names and values are CSS selectors. The actor extracts the first match’s text.</p>

<h3>What if one URL fails?</h3>
<p>That URL gets a dataset row with <code>error</code>; other URLs still process.</p>

<h3>Where is the combined export file?</h3>
<p>In the run’s default key-value store as <code>{exportBasename}.{extension}</code> (e.g. <code>EXPORT.csv</code>).</p>

<h2>Run locally</h2>

<ol>
  <li><code>pip install -r requirements.txt</code></li>
  <li>Create <code>INPUT.json</code> in this folder (see examples above).</li>
  <li><code>apify run</code> or run <code>main.py</code> in an Apify-compatible environment.</li>
</ol>

<h2>Deploy</h2>

<p>Push with Apify CLI or connect the Git repository. Schema files: <code>INPUT_SCHEMA.json</code>, <code>OUTPUT_SCHEMA.json</code>, <code>.actor/dataset_schema.json</code>, <code>Dockerfile</code>.</p>

<h2>Get started</h2>

<p>Add your URLs, optional selectors and export format, and start extracting structured web data with Python on Apify.</p>

# Actor input Schema

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

One or more URLs to scrape (one per line).
## `method` (type: `string`):

HTTP method used for requests.
## `cookies` (type: `string`):

Optional raw Cookie header value for authenticated sessions. Stored as a secret input and never written to the dataset.
## `bearerToken` (type: `string`):

Optional API or session bearer token. Stored as a secret input; sent as an Authorization header when set.
## `headers` (type: `object`):

Optional extra HTTP headers (JSON object). Use for custom auth or API keys. Stored as a secret input. Leave empty to use the default User-Agent only.
## `timeoutSecs` (type: `integer`):

Per-request timeout in seconds.
## `selectors` (type: `object`):

Optional mapping of fieldName -> CSS selector. The actor will extract the first matching text for each selector.
## `includeLinks` (type: `boolean`):

Extract and include page links (hrefs).
## `includeHtml` (type: `boolean`):

If enabled, the export file will contain a 'html' field with the raw HTML (can be large).
## `exportFormat` (type: `string`):

Export all extracted results to the key-value store.
## `exportBasename` (type: `string`):

Basename for the combined export file in the default key-value store (extension is added from export format, e.g. EXPORT.json). Not a credential.

## Actor input object example

```json
{
  "startUrls": [
    "https://example.com"
  ],
  "method": "GET",
  "timeoutSecs": 60,
  "selectors": {},
  "includeLinks": true,
  "includeHtml": false,
  "exportFormat": "json",
  "exportBasename": "EXPORT"
}
````

# Actor output Schema

## `pages` (type: `string`):

One dataset row per URL with title, meta tags, headings, links, and custom CSS selector fields.

## `exportJson` (type: `string`):

Combined results when exportFormat is json (default). Filename: {exportBasename}.json

## `exportCsv` (type: `string`):

Combined results when exportFormat is csv. Filename: {exportBasename}.csv

## `exportExcel` (type: `string`):

Combined results when exportFormat is excel. Filename: {exportBasename}.xlsx

## `exportXml` (type: `string`):

Combined results when exportFormat is xml. Filename: {exportBasename}.xml

## `exportHtml` (type: `string`):

Combined results when exportFormat is html. Filename: {exportBasename}.html

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        "https://example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sovanza.inc/python-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "startUrls": ["https://example.com"] }

# Run the Actor and wait for it to finish
run = client.actor("sovanza.inc/python-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://example.com"
  ]
}' |
apify call sovanza.inc/python-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Python Scraper",
        "description": "Python Scraper extracts web page data using Requests and BeautifulSoup. It collects titles, meta tags, headings, links, images, Open Graph data, text snippets, and custom CSS selector fields, with exports to JSON, CSV, Excel, XML, or HTML.",
        "version": "0.0",
        "x-build-id": "5Cxnn2sqZ9gB0Choa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sovanza.inc~python-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sovanza.inc-python-scraper",
                "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/sovanza.inc~python-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sovanza.inc-python-scraper",
                "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/sovanza.inc~python-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sovanza.inc-python-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more URLs to scrape (one per line).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "method": {
                        "title": "HTTP method",
                        "enum": [
                            "GET",
                            "POST"
                        ],
                        "type": "string",
                        "description": "HTTP method used for requests.",
                        "default": "GET"
                    },
                    "cookies": {
                        "title": "Cookie header",
                        "type": "string",
                        "description": "Optional raw Cookie header value for authenticated sessions. Stored as a secret input and never written to the dataset."
                    },
                    "bearerToken": {
                        "title": "Bearer token",
                        "type": "string",
                        "description": "Optional API or session bearer token. Stored as a secret input; sent as an Authorization header when set."
                    },
                    "headers": {
                        "title": "Request headers",
                        "type": "object",
                        "description": "Optional extra HTTP headers (JSON object). Use for custom auth or API keys. Stored as a secret input. Leave empty to use the default User-Agent only."
                    },
                    "timeoutSecs": {
                        "title": "Timeout (seconds)",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 60
                    },
                    "selectors": {
                        "title": "CSS selectors (optional)",
                        "type": "object",
                        "description": "Optional mapping of fieldName -> CSS selector. The actor will extract the first matching text for each selector.",
                        "default": {}
                    },
                    "includeLinks": {
                        "title": "Extract links",
                        "type": "boolean",
                        "description": "Extract and include page links (hrefs).",
                        "default": true
                    },
                    "includeHtml": {
                        "title": "Include raw HTML in export",
                        "type": "boolean",
                        "description": "If enabled, the export file will contain a 'html' field with the raw HTML (can be large).",
                        "default": false
                    },
                    "exportFormat": {
                        "title": "Export format",
                        "enum": [
                            "json",
                            "csv",
                            "excel",
                            "xml",
                            "html"
                        ],
                        "type": "string",
                        "description": "Export all extracted results to the key-value store.",
                        "default": "json"
                    },
                    "exportBasename": {
                        "title": "Export basename (KV store)",
                        "type": "string",
                        "description": "Basename for the combined export file in the default key-value store (extension is added from export format, e.g. EXPORT.json). Not a credential.",
                        "default": "EXPORT"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```