# Impressum & EU Legal Notice Extractor — Company & VAT Data (`haketa/impressum-legal-notice-extractor`) Actor

Turn a list of domains into structured company data from Impressum, Mentions légales, Aviso legal and other EU legal-notice pages: legal company name, VAT / USt-IdNr, managing director, registration number, court, address, email and phone. Fast, keyless B2B lead & KYB enrichment.

- **URL**: https://apify.com/haketa/impressum-legal-notice-extractor.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Lead generation, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 & EU Legal Notice Extractor — Company Name, VAT, Director & Address

Turn a plain list of domains into **structured company data** pulled from each site's legally‑required legal‑notice page — the German **Impressum**, French **Mentions légales**, Spanish **Aviso legal**, Italian **Note legali**, Dutch **Colofon** and their equivalents across Europe.

For every domain you get the **legal company name, VAT / USt‑IdNr, managing director, registration number, register court, postal address, email and phone** — the exact fields you need for B2B lead enrichment, KYB, compliance and sales research. Fast, keyless and built for bulk: paste **thousands to millions** of domains and let it run.

---

### Why this Actor is different

Most "email scrapers" crawl a whole website and return whatever addresses they stumble on. This Actor is **surgical**: it goes straight to the one page European businesses are **legally obliged** to publish — the legal notice — and reads the **structured company identity** from it.

That matters because the legal notice is:

- **Legally mandated** across the EU/EEA, so it exists on the vast majority of commercial sites and sits in the footer (one click away).
- **Structured and consistent** — it names the legal entity, its representatives, its VAT number and its commercial‑register entry. That is far richer than a random `info@` address.
- **High fill‑rate** — because publishing it is a legal requirement, the data is there to be read.

So instead of "an email, maybe," you get a **company record**: who the business legally is, who runs it, its tax and register IDs, and how to reach it.

---

### What you can do with it

- **B2B lead enrichment** — turn a list of company domains into a CRM‑ready table with legal name, decision‑maker, VAT and contact details.
- **KYB / compliance / onboarding** — confirm a counterparty's legal entity, registration number and register court before you do business.
- **Sales & prospecting** — reach the named managing director instead of a generic inbox.
- **Market & competitor research** — map the legal entities behind a set of brands or a whole industry.
- **Data cleaning & deduplication** — resolve many domains to their real legal company name and register ID.
- **Agency & directory building** — assemble structured company directories for a country or vertical.

---

### What you get — output fields

One record per domain:

| Field | Description |
| --- | --- |
| `domain` | The domain you supplied |
| `companyName` | Legal company name (e.g. `Flaconi GmbH`) |
| `address` | Street and postal city |
| `emails` | Email addresses found on the legal notice |
| `phone` | Phone number |
| `vatId` | VAT number / USt‑IdNr (e.g. `DE219349391`) |
| `managingDirector` | Managing director / legal representative |
| `registrationNumber` | Commercial‑register number (e.g. `HRB 133604`) |
| `registerCourt` | Registering court or chamber (e.g. `Düsseldorf`) |
| `legalPageUrl` | URL of the legal‑notice page that was read |
| `legalPageType` | `legal-notice` or `contact` (fallback) |
| `foundVia` | How the page was located |
| `error` | Populated only if nothing could be read |
| `scrapedAt` | ISO timestamp |

Not every field is present on every site — legal notices vary by country and company. Core fields (`companyName`, `emails`, `phone`, `address`) fill at a high rate; register/VAT/director fields are richest in German‑speaking markets (DE/AT/CH), where the legal‑notice format is most standardised.

---

### Example output

```json
{
  "domain": "flaconi.de",
  "companyName": "Flaconi GmbH",
  "address": "Franklinstraße 15a, 10587 Berlin",
  "emails": "service@flaconi.de",
  "phone": "030 / 920 363 63",
  "vatId": "DE289002936",
  "managingDirector": "Bastian Siebers, Alexandra Szarmach, Henry Brodski",
  "registrationNumber": "HRB 133604",
  "registerCourt": "Berlin",
  "legalPageUrl": "https://www.flaconi.de/impressum/",
  "legalPageType": "legal-notice",
  "foundVia": "footer-link",
  "scrapedAt": "2026-07-09T10:00:00.000Z"
}
````

```json
{
  "domain": "sipgate.de",
  "companyName": "sipgate GmbH",
  "address": "Gladbacher Straße 74, 40219 Düsseldorf",
  "emails": "info@sipgate.de",
  "phone": "+49 211 63553355",
  "vatId": "DE219349391",
  "managingDirector": "Thilo Salmon",
  "registrationNumber": "HRB 39841",
  "registerCourt": "Düsseldorf",
  "legalPageUrl": "https://www.sipgate.de/impressum",
  "legalPageType": "legal-notice",
  "foundVia": "footer-link",
  "scrapedAt": "2026-07-09T10:00:00.000Z"
}
```

***

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `domains` | array | — | **Required.** Domains to process. URLs and emails are accepted too — the domain is extracted automatically. |
| `contactPageFallback` | boolean | `true` | If no legal notice is found, try a contact page to still capture email and phone. |
| `maxConcurrency` | integer | `20` | How many domains to process in parallel. |
| `proxyConfiguration` | object | off | Apify Proxy. Off by default; enable if some targets block direct requests. |

#### Minimal input

```json
{
  "domains": ["sipgate.de", "flaconi.de", "teamviewer.com"]
}
```

#### Larger run

```json
{
  "domains": ["site1.de", "site2.fr", "site3.nl", "site4.it"],
  "contactPageFallback": true,
  "maxConcurrency": 30
}
```

You can paste domains in any of these forms — all are normalised to the bare domain:

- `example.com`
- `https://www.example.com/some/page`
- `hello@example.com`

***

### Supported countries & legal‑notice types

The Actor recognises legal‑notice pages in many languages and formats, including:

| Country | Legal‑notice name |
| --- | --- |
| Germany 🇩🇪 | Impressum |
| Austria 🇦🇹 | Impressum / Offenlegung |
| Switzerland 🇨🇭 | Impressum |
| France 🇫🇷 | Mentions légales |
| Spain 🇪🇸 | Aviso legal |
| Italy 🇮🇹 | Note legali / Dati societari |
| Netherlands 🇳🇱 | Colofon / Juridische informatie |
| Belgium 🇧🇪 | Mentions légales / Wettelijke vermeldingen |
| United Kingdom 🇬🇧 | Legal notice / Company information |
| Portugal 🇵🇹 | Aviso legal / Informação legal |
| … and more | Generic "Legal notice" / "Imprint" pages |

Coverage of the register/VAT/director fields is strongest for **DE, AT and CH**, where the Impressum is highly standardised. For other countries, expect reliable company name, address, email and phone, with the structured register fields where the site publishes them.

***

### How it works

1. You provide a list of domains.
2. For each domain, the Actor locates the legal‑notice page — first from the site's own footer link, then by checking the common legal‑notice paths used across Europe.
3. It reads the page and extracts the company fields listed above using multilingual, format‑aware parsing (for example, country‑specific VAT formats and register‑number patterns).
4. If no legal notice exists and `contactPageFallback` is on, it reads a contact page so you still get email and phone.
5. Each domain becomes one row in the dataset.

Everything runs on plain HTTP, so it's quick and inexpensive even on very large lists.

***

### Use cases in detail

#### 1. B2B lead enrichment

You have a list of company domains from a form, an event, or another scraper. Run them through this Actor and enrich each one with the legal company name, the managing director's name, the VAT number and a direct email/phone — a far stronger record than a bare domain.

#### 2. KYB and compliance onboarding

Before onboarding a supplier or partner, pull their legal notice to confirm the exact legal entity, its registration number and its register court. Combine `companyName` + `registrationNumber` + `registerCourt` to look the company up in the relevant commercial register.

#### 3. Sales prospecting to decision‑makers

`managingDirector` gives you the named person legally responsible for the business — ideal for personalised outreach in small and mid‑market companies, instead of emailing a generic inbox.

#### 4. Market mapping and competitive research

Feed in every domain in a niche or region and get the legal entities, locations and contacts behind them — a quick way to build a market map or competitor list.

#### 5. Data hygiene

Resolve many domains (including ones that redirect or rebrand) to a single canonical legal company name plus register ID, so your CRM isn't full of duplicates and guesses.

#### 6. Building directories

Assemble a structured, country‑specific business directory — legal name, address, VAT, contacts — from a seed list of domains.

***

### How to use it

1. Click **Try for free**.
2. Paste your list of domains into the **Domains** field.
3. (Optional) Adjust concurrency or enable proxy.
4. Click **Start**.
5. Export the results as **JSON, CSV, Excel** or **HTML table**, or pull them from the Apify API.

***

### Calling from the API

Start a run:

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "domains": ["sipgate.de", "flaconi.de"], "maxConcurrency": 20 }'
```

Fetch the results (JSON or CSV):

```bash
curl "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs/last/dataset/items?token=YOUR_APIFY_TOKEN&format=csv"
```

You can also schedule the Actor to keep a directory or lead list continuously up to date.

***

### Tips for the best results

- **Feed real company domains.** The legal notice is a business‑site feature; personal blogs and large closed platforms may not have one.
- **Combine with a DNS or contact tool.** Use it alongside other enrichment steps to build a complete company profile.
- **Use `companyName` + `registrationNumber` + `registerCourt` together** when you need to match a company in an official register.
- **Turn on proxy** only if a specific set of targets blocks direct requests — most legal‑notice pages don't need it.
- **Sort or filter by country** on your side by looking at the domain TLD or the VAT prefix (e.g. `DE`, `FR`, `IT`).

***

### Frequently asked questions

**Which page does it read?**
The site's legal‑notice page — Impressum, Mentions légales, Aviso legal, Note legali, Colofon and equivalents. It finds it from the footer link or by checking the standard legal‑notice paths.

**Why is a field sometimes empty?**
Legal notices differ by country and company. A small sole trader's notice won't list a "managing director," and not every country publishes a VAT number on the page. Core fields (name, address, email, phone) fill at a high rate; register/VAT/director fields are richest in German‑speaking markets.

**Can I pass URLs or emails instead of bare domains?**
Yes. `https://www.site.com/page` and `user@site.com` both normalise to `site.com`.

**How many domains can it handle?**
From a handful to millions. It processes domains in parallel and writes one row each.

**What if a site has no legal notice?**
With `contactPageFallback` on, it reads a contact page so you still capture email and phone. Otherwise the row is returned with an `error` note.

**In which format can I export?**
JSON, CSV, Excel, HTML table, or via the Apify API.

**Does it need any API key?**
No. Just paste your domains and run.

***

### Legal & responsible use

This Actor reads information that companies are **legally required to publish** on their own websites, and only from the public legal‑notice or contact page of the domains you supply.

You are responsible for how you use the results. In particular:

- Personal data (such as a managing director's name or email) is regulated in the EU by the **GDPR** and the **ePrivacy** rules even when it is publicly available. Make sure you have a lawful basis before processing or contacting individuals.
- Respect **marketing and anti‑spam laws** (GDPR, ePrivacy, national rules) when using contact details for outreach.
- Use the Actor only on domains you have a legitimate reason to check, and comply with each site's terms.

This tool is provided for lawful business, compliance and research purposes. It does not provide legal advice.

***

### Support

Need extra fields (e.g. share capital, DUNS, additional registers) or coverage for another country's legal‑notice format? Open an issue from the Actor's page and describe what you need.

# Actor input Schema

## `domains` (type: `array`):

Domains (or full URLs / emails — the domain is extracted) whose legal-notice page you want to read. Paste a list; handles thousands to millions.

## `contactPageFallback` (type: `boolean`):

If no legal notice is found, try a contact page (/kontakt, /contact) to still capture email and phone.

## `maxConcurrency` (type: `integer`):

How many domains to process in parallel. Lower it if you hit rate limits on a specific target.

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

Apify Proxy. Off by default — most legal-notice pages need no proxy. Turn on if some targets block direct requests.

## Actor input object example

```json
{
  "domains": [
    "heise.de",
    "golem.de",
    "contabo.com",
    "hetzner.com",
    "sevdesk.de",
    "mailjet.com"
  ],
  "contactPageFallback": true,
  "maxConcurrency": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `domain` (type: `string`):

The input domain

## `companyName` (type: `string`):

Legal company name

## `address` (type: `string`):

Street and postal city

## `emails` (type: `string`):

Email addresses found

## `phone` (type: `string`):

Phone number

## `vatId` (type: `string`):

VAT / USt-IdNr

## `managingDirector` (type: `string`):

Managing director / representative

## `registrationNumber` (type: `string`):

Company registration number

## `registerCourt` (type: `string`):

Registering court / chamber

## `legalPageUrl` (type: `string`):

URL of the legal-notice page

## `legalPageType` (type: `string`):

legal-notice or contact

## `foundVia` (type: `string`):

How the page was located

## `error` (type: `string`):

Error, if any

## `scrapedAt` (type: `string`):

Timestamp

# 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 = {
    "domains": [
        "heise.de",
        "golem.de",
        "contabo.com",
        "hetzner.com",
        "sevdesk.de",
        "mailjet.com"
    ],
    "maxConcurrency": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/impressum-legal-notice-extractor").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 = {
    "domains": [
        "heise.de",
        "golem.de",
        "contabo.com",
        "hetzner.com",
        "sevdesk.de",
        "mailjet.com",
    ],
    "maxConcurrency": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/impressum-legal-notice-extractor").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 '{
  "domains": [
    "heise.de",
    "golem.de",
    "contabo.com",
    "hetzner.com",
    "sevdesk.de",
    "mailjet.com"
  ],
  "maxConcurrency": 20
}' |
apify call haketa/impressum-legal-notice-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=haketa/impressum-legal-notice-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Impressum & EU Legal Notice Extractor — Company & VAT Data",
        "description": "Turn a list of domains into structured company data from Impressum, Mentions légales, Aviso legal and other EU legal-notice pages: legal company name, VAT / USt-IdNr, managing director, registration number, court, address, email and phone. Fast, keyless B2B lead & KYB enrichment.",
        "version": "0.1",
        "x-build-id": "bndd0FlgsrJKNOKqK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~impressum-legal-notice-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-impressum-legal-notice-extractor",
                "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/haketa~impressum-legal-notice-extractor/runs": {
            "post": {
                "operationId": "runs-sync-haketa-impressum-legal-notice-extractor",
                "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/haketa~impressum-legal-notice-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-impressum-legal-notice-extractor",
                "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": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "Domains",
                        "type": "array",
                        "description": "Domains (or full URLs / emails — the domain is extracted) whose legal-notice page you want to read. Paste a list; handles thousands to millions.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "contactPageFallback": {
                        "title": "Fall back to contact page",
                        "type": "boolean",
                        "description": "If no legal notice is found, try a contact page (/kontakt, /contact) to still capture email and phone.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many domains to process in parallel. Lower it if you hit rate limits on a specific target.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy. Off by default — most legal-notice pages need no proxy. Turn on if some targets block direct requests.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
