# German Imprint Leads (`studio-amba/german-imprint-leads`) Actor

Extracts contact and legal data from the mandatory Impressum page of German company websites: company name, legal form, managing directors, address, phone, fax, email, VAT ID, and Handelsregister entry. Give it company websites or domains, get back structured B2B lead data.

- **URL**: https://apify.com/studio-amba/german-imprint-leads.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 result scrapeds

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/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

## German Imprint Leads

Extract company contact and legal data straight from the **Impressum** page of German company websites. Every commercial website registered in Germany is legally required (§ 5 TMG) to publish an Impressum with the company's legal name, address, and contact details — this actor turns that legally-mandated data into a clean, structured lead list.

Give it a list of company websites (or just plain domains) and get back the company's legal name, legal form, managing directors, full address, phone, fax, email, VAT ID (USt-IdNr), and commercial register entry (Handelsregister). No login, no API key, no scraping product pages — just the page every German business is required to publish.

### Why use this actor?

The German Impressum is one of the few places on the internet where businesses are legally forced to publish accurate, up-to-date contact information: a real company name, a real address, and a way to reach a real decision-maker. That makes it one of the highest-quality sources for B2B lead generation, sales prospecting, and market research into the German market — far more reliable than guessing contact details from a "Kontakt" form.

Typical users:

- **Sales and outbound teams** building a prospect list of German companies in a given sector, with a verified company name, address, and contact email for each.
- **Market researchers and analysts** who need to verify a German counterparty's legal form, registered address, or Handelsregister entry before doing business.
- **Lead-gen agencies** enriching an existing list of German company domains with structured contact data.
- **Compliance and due-diligence teams** cross-checking a company's legal name and VAT ID against its public Impressum.

### How to scrape German Impressum data

Point the actor at German company websites and it does the rest: find the Impressum page, and pull out every field a standardized German legal notice is required to contain.

#### 1. Give it company URLs

Add company homepages or direct Impressum/Imprint URLs to **Start URLs**. A homepage is enough — the actor automatically looks for a link to the Impressum (checking anchor text and href for "Impressum", "Imprint", "Legal Notice", etc.) and, if it can't find one, tries the ~18 most common Impressum URL paths directly (`/impressum`, `/de/impressum`, `/unternehmen/impressum`, `/legal/impressum`, and so on).

```json
{
  "startUrls": [
    { "url": "https://www.example.de" },
    { "url": "https://www.example.de/impressum" }
  ]
}
````

#### 2. Or just paste a list of domains

If you already have a list of company domains (from a CRM export, a search result list, or another scraper), paste them into **Domains** — one per line, or comma-separated. `https://` is added automatically.

```json
{
  "domains": "example.de\nanother-company.de\nthird-company.com"
}
```

You can combine both **Start URLs** and **Domains** in the same run — the actor deduplicates by domain, so each company only appears once in the output.

#### 3. Set a result limit

**Max Results** caps how many companies the actor returns (one record per unique domain). Useful for testing on a small batch before running a large list.

#### 4. Run it

The actor visits each domain, finds the Impressum page, and extracts every field it can find. German Impressum pages follow legally standardized wording (§ 5 TMG for the base requirements, plus § 55 RStV / § 18 MStV for editorial content and Art. 13 GDPR-adjacent disclosures), which makes labeled-field extraction reliable across very different site designs — from a single-page SME site to a DAX-listed corporation's legal department boilerplate.

### What data does German Imprint Leads extract?

| Field | Type | Description |
|-------|------|--------------|
| **companyName** | String | Registered company name, including legal form (e.g. "Musterfirma GmbH") |
| **legalForm** | String | Legal form suffix only (GmbH, AG, UG, GmbH & Co. KG, KGaA, eG, e.K., ...) |
| **managingDirectors** | String | Managing director(s) / Vorstand / Geschäftsführung named in the Impressum |
| **street** | String | Street and house number |
| **postalCode** | String | 5-digit German postal code |
| **city** | String | City / postal area |
| **phone** | String | Phone number, if published |
| **fax** | String | Fax number, if published (increasingly rare) |
| **email** | String | null | Primary contact email (first one found) |
| **emails** | Array | All contact emails found on the page (mailto links, Cloudflare-obfuscated addresses, and `[at]`/`[dot]`-style obfuscation are all decoded) |
| **vatId** | String | VAT identification number (Umsatzsteuer-IdNr., format `DE123456789`) |
| **commercialRegister** | String | Full Handelsregister entry (court + register number), e.g. "Amtsgericht München, HRB 228747" |
| **registerCourt** | String | Registration court (Amtsgericht) only |
| **registerNumber** | String | Register number only (e.g. "HRB 228747") |
| **domain** | String | The company's root domain (deduplication key) |
| **website** | String | The company's canonical website URL |
| **impressumUrl** | String | The exact URL the data was extracted from |
| **scrapedAt** | String | ISO timestamp of extraction |

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|--------------|
| **Start URLs** | Array | 5 demo companies | Company homepages or direct Impressum URLs |
| **Domains** | String | — | Alternative: a plain list of domains, one per line or comma-separated |
| **Max Results** | Integer | 100 | Maximum number of company records to return |
| **Proxy Configuration** | Object | Apify default | Most German SME sites work fine on the default proxy; switch to residential if you see blocked requests |

### Example output

```json
{
  "domain": "obi.de",
  "website": "https://obi.de",
  "impressumUrl": "https://www.obi.de/legal/impressum",
  "companyName": "OBI Home and Garden GmbH",
  "legalForm": "GmbH",
  "managingDirectors": "Dr. Sebastian Gundel, Jochen Ludwig",
  "street": "Albert-Einstein-Straße 7-9",
  "postalCode": "42929",
  "city": "Wermelskirchen",
  "phone": "02196 90 62 000",
  "fax": "",
  "email": "impressum@obi.de",
  "emails": ["impressum@obi.de", "quality-management@obi.de"],
  "vatId": "DE362559161",
  "commercialRegister": "Amtsgericht Köln, HRB 115846",
  "registerCourt": "Köln",
  "registerNumber": "HRB 115846",
  "scrapedAt": "2026-07-16T19:31:53.485Z"
}
```

### How the extraction works

German Impressum pages are legally required to contain the same set of facts, but the HTML shape varies enormously — from a five-line static page on a small business site to a sprawling corporate legal-notice page with dozens of unrelated navigation links. The actor handles both by:

1. Converting the page into a line-by-line text representation (splitting on block elements like `<p>`, `<div>`, `<li>`, `<br>`), since some sites put the whole address on one line and others break it across several.
2. Matching legally-standardized label patterns (Geschäftsführer, Handelsregister, Amtsgericht, USt-IdNr., Telefon, Fax) rather than relying on CSS selectors, which differ on every site.
3. Validating that a value actually *looks* like the thing it claims to be (a phone-shaped string, a name-shaped string, a 5-digit postal code) before accepting it — this filters out navigation menu items and unrelated page content that happen to contain the same keywords.
4. Decoding common email obfuscation techniques: `mailto:` links, Cloudflare's `data-cfemail` protection, and manual obfuscation like `info[at]example[dot]de`.

### Cost estimate

Pricing is pay-per-result. Each run is a lightweight Cheerio-based crawl (no browser rendering), so compute cost per company is negligible — the vast majority of the cost is the per-result lead price, not compute.

### Limitations

- Extraction is regex/pattern-based against legally standardized wording. It's tuned against a wide range of real German company Impressum pages (from small businesses to DAX corporations) and handles the vast majority of layouts, but an unusually worded or heavily restructured page can still result in a missing field — check `managingDirectors`, `street`, `phone`, and `fax` in particular, since these are more free-form than the labeled `vatId` / `commercialRegister` fields.
- Sole proprietors and freelancers (Einzelunternehmer) without a Handelsregister entry or a VAT ID will have those fields empty — that's correct behavior, not a bug, since the underlying Impressum genuinely has no such data.
- Sites protected by aggressive anti-bot systems (Cloudflare/Akamai challenge pages) may need a residential proxy — switch **Proxy Configuration** if you see blocked requests in the run log.
- One record per unique domain. If a company runs its Impressum on a separate legal-entity domain per brand, scrape each brand domain separately.

### Related scrapers

- **Handelsregister Scraper** — official German commercial register data (Handelsregister), a complementary source to this actor's Impressum-page extraction.
- **WLW Scraper** — B2B supplier and company data from wlw.de (Wer liefert was).
- **KVK Scraper** — company data from the Dutch Chamber of Commerce, for the equivalent Dutch use case.

### Data source and legality

This actor reads only the Impressum page, which German law (§ 5 TMG) requires every commercial website to publish publicly, without login or paywall. No scraping of login-protected areas, no bypassing of any access control. The data itself (company name, address, register entry) is information the business is legally obligated to disclose to the public.

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API — maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

# Actor input Schema

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

Company homepages or direct Impressum/Imprint page URLs to scrape. A homepage URL is fine — the actor finds the Impressum link automatically.

## `domains` (type: `string`):

Optional. A list of bare domains, one per line or comma-separated (e.g. example.de). https:// is added automatically and the actor treats each as a homepage to crawl. Use this for quickly pasting a long list of company domains without building a URL list.

## `maxResults` (type: `integer`):

Maximum number of company Impressum records to return. One record per unique domain.

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

Most German SME websites don't need anything more than Apify's default datacenter proxy. Switch to residential only if you see blocked requests in the log.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tchibo.de/c/service-impressum"
    },
    {
      "url": "https://www.check24.de/unternehmen/impressum/"
    },
    {
      "url": "https://www.tui.com/impressum/"
    },
    {
      "url": "https://www.obi.de/impressum"
    },
    {
      "url": "https://www.vodafone.de/impressum.html"
    }
  ],
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": [
        {
            "url": "https://www.tchibo.de/c/service-impressum"
        },
        {
            "url": "https://www.check24.de/unternehmen/impressum/"
        },
        {
            "url": "https://www.tui.com/impressum/"
        },
        {
            "url": "https://www.obi.de/impressum"
        },
        {
            "url": "https://www.vodafone.de/impressum.html"
        }
    ],
    "domains": "",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/german-imprint-leads").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": [
        { "url": "https://www.tchibo.de/c/service-impressum" },
        { "url": "https://www.check24.de/unternehmen/impressum/" },
        { "url": "https://www.tui.com/impressum/" },
        { "url": "https://www.obi.de/impressum" },
        { "url": "https://www.vodafone.de/impressum.html" },
    ],
    "domains": "",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/german-imprint-leads").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": [
    {
      "url": "https://www.tchibo.de/c/service-impressum"
    },
    {
      "url": "https://www.check24.de/unternehmen/impressum/"
    },
    {
      "url": "https://www.tui.com/impressum/"
    },
    {
      "url": "https://www.obi.de/impressum"
    },
    {
      "url": "https://www.vodafone.de/impressum.html"
    }
  ],
  "domains": "",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/german-imprint-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=studio-amba/german-imprint-leads",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "German Imprint Leads",
        "description": "Extracts contact and legal data from the mandatory Impressum page of German company websites: company name, legal form, managing directors, address, phone, fax, email, VAT ID, and Handelsregister entry. Give it company websites or domains, get back structured B2B lead data.",
        "version": "0.0",
        "x-build-id": "wYquShbF2ooYgpacK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~german-imprint-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-german-imprint-leads",
                "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/studio-amba~german-imprint-leads/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-german-imprint-leads",
                "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/studio-amba~german-imprint-leads/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-german-imprint-leads",
                "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": {
                    "startUrls": {
                        "title": "Company Website URLs",
                        "type": "array",
                        "description": "Company homepages or direct Impressum/Imprint page URLs to scrape. A homepage URL is fine — the actor finds the Impressum link automatically.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "domains": {
                        "title": "Domains (alternative to Start URLs)",
                        "type": "string",
                        "description": "Optional. A list of bare domains, one per line or comma-separated (e.g. example.de). https:// is added automatically and the actor treats each as a homepage to crawl. Use this for quickly pasting a long list of company domains without building a URL list."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of company Impressum records to return. One record per unique domain.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Most German SME websites don't need anything more than Apify's default datacenter proxy. Switch to residential only if you see blocked requests in the log."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```