# Impressum Standby Scraper (HTTP Version) (`dominic-quaiser/impressum-standby-scraper-http`) Actor

Scrape German imprint pages instantly. Using a HTTP for fast scraping of common simple imprint pages. This Apify Actor finds and extracts structured contact & legal data from any German website — company name, address, phone, fax, email, VAT ID, register number, social media & decision makers.

- **URL**: https://apify.com/dominic-quaiser/impressum-standby-scraper-http.md
- **Developed by:** [Dominic M. Quaiser](https://apify.com/dominic-quaiser) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.52 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Impressum Standby Scraper (HTTP Version)

Find and extract structured contact and legal information from German imprint pages (**"Impressum"**) — in real time, one URL per request. Send a homepage URL to the actor's HTTP endpoint and it automatically discovers the site's imprint page and returns clean, structured data: company name, address, phone/fax, email, commercial register number, VAT ID, social media links, and decision-makers.

This actor runs in **Apify Standby mode** as a long-lived HTTP server. That makes it ideal for on-demand enrichment: low per-request latency, no run start-up overhead per URL, and a simple `GET`/`POST` API you can call directly from your application, a workflow tool, or another actor.

### ℹ️ Which version is this?

This scraper is published in **two variants**, optimised for different kinds of websites:

#### 🚀 HTTP version (this actor)

A **fast, lightweight** scraper that fetches pages over plain HTTP. Perfect for the vast majority of imprint pages, which are server-rendered and don't require JavaScript. It carries **no headless-browser charge** and responds in a fraction of the time.

👉 Need to scrape modern, JavaScript-heavy sites (e.g. Next.js / React apps that render their navigation client-side)? Use the **[Playwright version](https://apify.com/dominic-quaiser/impressum-standby-scraper)** instead.

---

### 💡 Features

- **Automatic imprint-page discovery**: point the actor at a homepage; it finds the correct "Impressum" page for you.
- **Selective data extraction**: request only the fields you need, from basic contact info to ML-extracted decision-makers.
- **Real-time Standby API**: `GET` or `POST` a single URL and get structured JSON back immediately. One request is processed at a time per container.
- **Proxy support**: integrates with Apify Proxy for IP rotation and to reduce blocking.
- **Structured JSON output**: clean, predictable records ready for your CRM, database, or downstream pipeline.

### 🔌 Standby API

In Standby mode the actor exposes an HTTP server. Apify gives every Standby actor a base URL; append the query parameters below and authenticate with your Apify API token (e.g. as a `?token=` query parameter or `Authorization: Bearer <token>` header).

#### `GET /` — scrape one URL (query string)

| Parameter         | Required | Description                                                                                                                   |
| ----------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `startUrl`        | **Yes**  | Homepage URL to scrape. The actor discovers the imprint page automatically. `https://` is prepended if the scheme is missing. |
| `fieldsToExtract` | No       | Comma-separated list of fields to extract. Defaults to all fields.                                                            |
| `metaData`        | No       | `true`/`false` — include extra technical details in the response. Default `false`.                                            |

```bash
curl 'https://dominic-quaiser--impressum-standby-scraper-http.apify.actor/?startUrl=https://www.renault.de/&fieldsToExtract=company_name,emails,phone_number&token=<APIFY_TOKEN>'
````

#### `POST /` — scrape one URL (JSON body)

```bash
curl -X POST 'https://dominic-quaiser--impressum-standby-scraper-http.apify.actor/?token=<APIFY_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{
        "startUrl": "https://www.renault.de/",
        "fieldsToExtract": ["company_name", "emails", "phone_number"],
        "metaData": false
      }'
```

#### `GET /health` — health check & stats

Returns `200` with a snapshot of running counters (total requests, successful scrapes, errors, etc.). Useful for uptime checks.

```bash
curl 'https://dominic-quaiser--impressum-standby-scraper-http.apify.actor/health'
```

#### Responses

| Status | Meaning                                                                                                                                                             |
| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `200`  | Scrape completed. Body is `{ "url": ..., "result": { ... } }`, or `{ "url": ..., "result": null, "message": "No data extracted" }` when nothing could be extracted. |
| `400`  | Missing or invalid `startUrl`, or an invalid JSON body.                                                                                                             |
| `500`  | Unhandled scraper error.                                                                                                                                            |
| `504`  | Processing timed out.                                                                                                                                               |

Each successful result is **also pushed to the actor's default dataset**, so you can browse or export your scrape history from the Apify Console even when calling the API directly.

### 📊 Extractable data

Select any combination of the following fields via `fieldsToExtract`:

| Field                  | Description                                                                                                                        | Type     |
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | -------- |
| **`company_name`**     | The official company name, with a `confidence` score for the match.                                                                | `Object` |
| **`business_address`** | Full address parsed into `full_address`, `street`, `house_number`, `postal_code`, `city`.                                          | `Object` |
| **`phone_number`**     | One or more phone numbers, keyed `phone_1`, `phone_2`, …                                                                           | `Object` |
| **`fax_number`**       | One or more fax numbers, keyed `fax_1`, `fax_2`, …                                                                                 | `Object` |
| **`emails`**           | One or more email addresses; emails matching the site's domain are prioritised.                                                    | `Object` |
| **`register_number`**  | Commercial register number ("Handelsregisternummer") and the registration `court` ("Registergericht").                             | `Object` |
| **`vat_id`**           | German VAT ID ("Umsatzsteuer-ID") with checksum validation, e.g. `DE123456788`.                                                    | `Object` |
| **`social_media`**     | Links to platforms like LinkedIn, Xing, Facebook, Instagram, etc.                                                                  | `Object` |
| **`decision_makers`**  | **(Premium)** Names of key decision-makers ("Entscheidungsträger") extracted via an external NER (Named Entity Recognition) model. | `Array`  |

> Numbered outputs (emails, phone numbers, …) are ordered by how likely each value is the company's main contact.

### 📤 Output structure

The exact fields depend on your `fieldsToExtract` selection.

```json
{
  "start_url": "https://muster-firma.de/",
  "imprint_url": "https://muster-firma.de/impressum",
  "company_name": {
    "name": "Muster GmbH",
    "confidence": 1
  },
  "business_address": {
    "full_address": "Musterstraße 123, 12345 Berlin",
    "street": "Musterstraße",
    "house_number": "123",
    "postal_code": "12345",
    "city": "Berlin"
  },
  "phone_number": { "phone_1": "+493012345678" },
  "fax_number": { "fax_1": "+493012345679" },
  "emails": { "email_1": "kontakt@muster-firma.de" },
  "register_number": {
    "number": "HRB 12345 B",
    "court": "Amtsgericht Charlottenburg"
  },
  "vat_id": { "vat_id": "DE123456788" },
  "social_media": {
    "linkedin": "https://www.linkedin.com/company/muster-firma"
  },
  "decision_makers": ["Max Mustermann"],
  "metadata": {
    "domain": "muster-firma.de",
    "fetch_method": "http",
    "fallback_attempted": false,
    "scraped_at": "2026-06-22T12:04:48.003780"
  }
}
```

The `metadata` block is only included when `metaData` is enabled.

### ⚖️ Legal disclaimer

You are solely responsible for determining the legality of your use of this actor and the data it generates. Scraping and handling data — particularly personal information — is subject to legal frameworks such as the GDPR (DSGVO), copyright law, and the terms of service of the sites you scrape. Ensure your use case is compliant with all applicable laws. This text is not legal advice.

#### GDPR notice: "Decision Makers" feature

The **`decision_makers`** feature uses an external API hosted on a private server in **Europe (Germany)** to process data.

- **What is processed**: the text of the imprint page is sent to the API to identify personal names.
- **Why**: the NER model needs the page text to accurately extract decision-makers.
- **Data controller**: you, the user, are the data controller; the actor's developer acts as data processor for this task.
- **Location & compliance**: all processing occurs within the EU and is subject to the GDPR (DSGVO).
- **Data storage**: the text is processed in-memory and is **not** stored or logged on the external server.
- **Important**: this processing is external to the Apify platform and not covered by Apify's DPA. By using this feature you acknowledge this separate processing activity.

### 🤖 Other actors

Combine the German Imprint Scraper with other actors to build powerful data pipelines:

- **[Gelbe Seiten (German Yellow Pages) Scraper](https://apify.com/dominic-quaiser/gelbe-seiten-german-yellow-pages-scraper)**: extract business listings from Germany's Yellow Pages with three detail levels.
- **[Das Telefonbuch Scraper](https://apify.com/dominic-quaiser/das-telefonbuch-scraper)**: extract business listings from Das Telefonbuch, Germany's official telephone directory.
- **[Das Örtliche Scraper](https://apify.com/dominic-quaiser/das-oerdliche-scraper)**: extract business listings from Das Örtliche, Germany's nationwide telephone directory.

### 🎯 Use cases

- **Lead generation** — build targeted contact lists for sales and marketing.
- **Real-time enrichment** — call the Standby API to enrich a record the moment a lead enters your CRM.
- **Compliance & verification** — check for legally compliant imprint information.
- **Market research** — aggregate company data for a specific industry or region.

### 🛠️ Maintainer

- **Author**: Dominic M. Quaiser
- **Contact**: <dev@krake.run>
- **Website**: [krake.run](https://krake.run/)

# Actor input Schema

## `startUrl` (type: `string`):

Used only for one-shot (non-standby) runs. The scheme (https://) is prepended automatically if missing. In standby mode, supply the URL per HTTP request instead.

## `fieldsToExtract` (type: `array`):

Choose the specific pieces of information you want to collect from the imprint pages.

## `metaData` (type: `boolean`):

When enabled, the output will include extra technical details. This is useful for troubleshooting or detailed analysis.

## `proxyConfiguration` (type: `object`):

Specifies proxy servers that will be used by the scraper in order to hide its origin.

## Actor input object example

```json
{
  "startUrl": "https://www.renault.de/",
  "fieldsToExtract": [
    "company_name",
    "business_address",
    "phone_number",
    "fax_number",
    "emails",
    "register_number",
    "vat_id",
    "social_media",
    "decision_makers"
  ],
  "metaData": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All extracted imprint records with full metadata (JSON format)

## `datasetCsv` (type: `string`):

Download all results as a CSV spreadsheet

## `datasetExcel` (type: `string`):

Download all results as an Excel spreadsheet (XLSX format)

## `viewOverview` (type: `string`):

All extracted fields for every result — the complete picture in one view

## `viewContactInfo` (type: `string`):

Company name, email addresses, and phone/fax numbers — ready for outreach

## `viewCompanyDetails` (type: `string`):

Legal company information — name, address, register number, and VAT ID

## `viewDecisionMakers` (type: `string`):

Extracted Geschäftsführer and other named responsible persons per company

## `viewSocialMedia` (type: `string`):

Social media profile links found on each imprint page

# 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 = {
    "startUrl": "https://www.renault.de/",
    "fieldsToExtract": [
        "company_name",
        "business_address",
        "phone_number",
        "fax_number",
        "emails",
        "register_number",
        "vat_id",
        "social_media",
        "decision_makers"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dominic-quaiser/impressum-standby-scraper-http").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 = {
    "startUrl": "https://www.renault.de/",
    "fieldsToExtract": [
        "company_name",
        "business_address",
        "phone_number",
        "fax_number",
        "emails",
        "register_number",
        "vat_id",
        "social_media",
        "decision_makers",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("dominic-quaiser/impressum-standby-scraper-http").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 '{
  "startUrl": "https://www.renault.de/",
  "fieldsToExtract": [
    "company_name",
    "business_address",
    "phone_number",
    "fax_number",
    "emails",
    "register_number",
    "vat_id",
    "social_media",
    "decision_makers"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call dominic-quaiser/impressum-standby-scraper-http --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dominic-quaiser/impressum-standby-scraper-http",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Impressum Standby Scraper (HTTP Version)",
        "description": "Scrape German imprint pages instantly. Using a HTTP for fast scraping of common simple imprint pages. This Apify Actor finds and extracts structured contact & legal data from any German website — company name, address, phone, fax, email, VAT ID, register number, social media & decision makers.",
        "version": "0.0",
        "x-build-id": "QYVZzIM5e0OgBGkwF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dominic-quaiser~impressum-standby-scraper-http/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dominic-quaiser-impressum-standby-scraper-http",
                "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/dominic-quaiser~impressum-standby-scraper-http/runs": {
            "post": {
                "operationId": "runs-sync-dominic-quaiser-impressum-standby-scraper-http",
                "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/dominic-quaiser~impressum-standby-scraper-http/run-sync": {
            "post": {
                "operationId": "run-sync-dominic-quaiser-impressum-standby-scraper-http",
                "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": {
                    "startUrl": {
                        "title": "Website to Scrape",
                        "type": "string",
                        "description": "Used only for one-shot (non-standby) runs. The scheme (https://) is prepended automatically if missing. In standby mode, supply the URL per HTTP request instead."
                    },
                    "fieldsToExtract": {
                        "title": "Data to Extract",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose the specific pieces of information you want to collect from the imprint pages.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "company_name",
                                "business_address",
                                "phone_number",
                                "fax_number",
                                "emails",
                                "register_number",
                                "vat_id",
                                "social_media",
                                "decision_makers"
                            ],
                            "enumTitles": [
                                "Company Name (Firmenname)",
                                "Business Address (Geschäftsadresse)",
                                "Phone Number (Telefonnummer)",
                                "Fax Number (Faxnummer)",
                                "Email Address (E-Mail-Adresse)",
                                "Register Number (Handelsregisternummer)",
                                "VAT ID (Umsatzsteuer-ID)",
                                "Social Media (Soziale Medien)",
                                "Decision Makers (Entscheidungsträger—Geschäftsführer, Vorstand)"
                            ]
                        },
                        "default": [
                            "company_name",
                            "business_address",
                            "phone_number",
                            "fax_number",
                            "emails",
                            "register_number",
                            "vat_id",
                            "social_media",
                            "decision_makers"
                        ]
                    },
                    "metaData": {
                        "title": "Include Metadata",
                        "type": "boolean",
                        "description": "When enabled, the output will include extra technical details. This is useful for troubleshooting or detailed analysis.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Specifies proxy servers that will be used by the scraper in order to hide its origin.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
