# EUR-Lex EU Legislation Scraper (`automation-lab/eur-lex-eu-legislation-scraper`) Actor

Scrape EUR-Lex EU legislation search results, CELEX identifiers, dates, document metadata, and official links.

- **URL**: https://apify.com/automation-lab/eur-lex-eu-legislation-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## EUR-Lex EU Legislation Scraper

Scrape EUR-Lex search results and legal document metadata from the official EU law portal. The actor helps compliance teams, legal researchers, policy analysts, and market-intelligence teams monitor regulations, directives, decisions, case law, CELEX IDs, document dates, Official Journal citations, and official EUR-Lex links.

### What does EUR-Lex EU Legislation Scraper do?

This actor turns EUR-Lex searches into structured datasets. If the EUR-Lex website is temporarily protected by its AWS WAF challenge, the actor automatically continues through the EU Publications Office's official CELLAR knowledge graph.

- 🔎 Search by keyword, CELEX ID, or pasted EUR-Lex URL
- ⚖️ Extract one row per EU legal document
- 🧾 Capture CELEX IDs, titles, form, author, date, status, and citations
- 🔗 Return official EUR-Lex document, HTML, and PDF links
- 🌍 Select any official EUR-Lex language code
- 📄 Optionally fetch document HTML text excerpts for deeper analysis

### Who is it for?

- **EU compliance teams** tracking new and amended legal acts.
- **Law firms** building evidence packs for client matters.
- **Policy analysts** monitoring topics such as climate, AI, sanctions, procurement, or digital regulation.
- **Market-intelligence vendors** feeding legal-document watchlists into dashboards.
- **Researchers and journalists** collecting official EU legal references at scale.

### Why use this actor?

EUR-Lex is authoritative, but manual searches are slow to repeat and hard to export consistently. This scraper produces structured rows that can be exported to CSV, JSON, Excel, Google Sheets, databases, or downstream automation.

### What data can you extract?

| Field | Description |
| --- | --- |
| `celexId` | Official CELEX identifier |
| `title` | Document title from EUR-Lex |
| `documentUrl` | Official EUR-Lex document URL |
| `htmlUrl` | HTML text URL when available |
| `pdfUrl` | PDF URL when available |
| `form` | Regulation, directive, decision, etc. |
| `author` | Issuing institution or author |
| `dateOfDocumentIso` | Normalized document date |
| `legalStatus` | In-force status when shown by EUR-Lex |
| `ojCitation` | Official Journal citation |
| `latestConsolidatedVersion` | Latest consolidated version date/link text |
| `availableLanguages` | Language codes listed by EUR-Lex |
| `matchedKeyword` | Keyword that produced the row |
| `rank` | Search result rank |
| `sourceSearchUrl` | EUR-Lex page that produced the row |

### How much does it cost to scrape EUR-Lex legislation?

This actor uses pay-per-event pricing. There is a small run-start event and a per-document result event. You can control spend with `maxItems`, keyword count, and whether `fetchDocumentHtml` is enabled.

### Quick start

1. Open the actor on Apify.
2. Enter one or more keywords, for example `climate` or `digital services act`.
3. Set `maxItems` to the number of documents you need.
4. Choose a language such as `EN`, `FR`, or `DE`.
5. Run the actor.
6. Export the dataset in CSV, JSON, Excel, or via API.

### Input: keywords

Use `keywords` for normal recurring monitoring. Each keyword creates a EUR-Lex quick search and the actor follows result pages until `maxItems` is reached.

Examples:

- `climate`
- `artificial intelligence`
- `public procurement`
- `financial sanctions`

### Input: CELEX IDs

Use `celexIds` when you already know exact documents.

Examples:

- `32021R1119`
- `32022R2065`
- `32016R0679`

### Input: EUR-Lex search URLs

Use `startUrls` when you have built a complex query in EUR-Lex and want the actor to process that exact result page. Paste the browser URL from EUR-Lex search or legal-content pages.

### Language support

EUR-Lex supports all official EU language codes. The input schema includes BG, ES, CS, DA, DE, ET, EL, EN, FR, GA, HR, IT, LV, LT, HU, MT, NL, PL, PT, RO, SK, SL, FI, and SV.

### Date filtering

The actor extracts `Date of document` when EUR-Lex exposes it on the result card. You can filter client-side with `dateFrom` and `dateTo` in `YYYY-MM-DD` format.

### Optional document HTML text

Enable `fetchDocumentHtml` if you need a text excerpt from the legal-content HTML page. Keep it disabled for faster, cheaper metadata watchlists.

### Output example

```json
{
  "celexId": "32021R1119",
  "title": "Regulation (EU) 2021/1119 ... European Climate Law",
  "form": "Regulation",
  "author": "European Parliament, Council of the European Union",
  "dateOfDocumentIso": "2021-06-30",
  "legalStatus": "In force",
  "htmlUrl": "https://eur-lex.europa.eu/legal-content/EN/TXT/HTML/?uri=CELEX:32021R1119",
  "pdfUrl": "https://eur-lex.europa.eu/legal-content/EN/TXT/PDF/?uri=CELEX:32021R1119"
}
````

### Tips for better results

- Use specific legal or policy terms instead of very broad words.
- Use CELEX IDs for exact-document enrichment.
- Keep `fetchDocumentHtml` off unless you need text.
- Use `maxItems` to cap recurring monitoring costs.
- Store `sourceSearchUrl` for auditability.

### Integrations

You can connect the dataset to:

- 📊 Google Sheets dashboards for compliance watchlists
- 🧠 LLM summarization pipelines for new legal acts
- 🗄️ SQL warehouses for legal analytics
- 🔔 Slack or email alerts for newly matched CELEX IDs
- 🧩 Apify integrations and webhooks for scheduled monitoring

### API usage: Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/eur-lex-eu-legislation-scraper').call({
  keywords: ['climate'],
  language: 'EN',
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

### API usage: Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/eur-lex-eu-legislation-scraper').call(run_input={
    'keywords': ['digital services act'],
    'language': 'EN',
    'maxItems': 50,
})
print(run['defaultDatasetId'])
```

### API usage: cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~eur-lex-eu-legislation-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["climate"],"language":"EN","maxItems":100}'
```

### MCP usage

Use the Apify MCP server with tools scoped to this actor:

`https://mcp.apify.com/?tools=automation-lab/eur-lex-eu-legislation-scraper`

#### Claude Code

Add the actor-scoped HTTP server:

```bash
claude mcp add --transport http apify-eurlex 'https://mcp.apify.com/?tools=automation-lab/eur-lex-eu-legislation-scraper'
```

#### Claude Desktop

Add the following server to your Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify-eurlex": {
      "url": "https://mcp.apify.com/?tools=automation-lab/eur-lex-eu-legislation-scraper"
    }
  }
}
```

#### Cursor

Open **Settings → Tools & Integrations → MCP**, add a custom server, and use the same `mcpServers` JSON configuration shown above.

#### VS Code

Open the Command Palette, choose **MCP: Add Server**, select **HTTP**, and enter the actor-scoped MCP URL shown above. Name the server `apify-eurlex`.

#### Example prompts:

- "Run the EUR-Lex scraper for climate law and summarize the newest regulations."
- "Extract CELEX IDs for digital services act documents and return official PDF links."
- "Monitor EU procurement legislation and prepare a weekly compliance digest."

### Scheduling

Run the actor daily, weekly, or monthly on Apify. Use the same keyword list each time and compare CELEX IDs against previous datasets to detect new or changed documents.

### Legality

EUR-Lex is a public official legal-information website. This actor accesses public pages and does not bypass authentication. Users are responsible for complying with EUR-Lex terms, EU database rights, and internal legal policies.

### FAQ

#### Can I scrape EUR-Lex by CELEX ID?

Yes. Add identifiers such as `32021R1119` to `celexIds` for exact document extraction.

#### Does this actor need an EUR-Lex account?

No. It uses public EUR-Lex pages and the official public CELLAR endpoint; no cookies or private credentials are required.

### Troubleshooting

#### Why did I get fewer results than expected?

Your `maxItems` may be low, the keyword may have few results, or date filters may remove rows. Try a broader keyword or increase the limit.

#### Why is `documentHtmlText` empty?

Some documents may not expose a standard HTML text page or the request may fail. The metadata row is still saved.

### Related scrapers

Explore other Automation Lab actors at `https://apify.com/automation-lab/` for regulatory monitoring, public records, tenders, and business intelligence workflows.

### Changelog

- Reliability update: keyword and CELEX lookups now continue through the official CELLAR knowledge graph when EUR-Lex serves a WAF challenge.
- Initial version: keyword, CELEX ID, and EUR-Lex URL inputs; metadata extraction; optional HTML text fetch.

### Support

If you need a field that EUR-Lex exposes but this actor does not yet return, open an Apify issue with an example URL and desired output field.

### Field reference

`celexId`

`title`

`documentUrl`

`htmlUrl`

`pdfUrl`

`sourceSearchUrl`

`rank`

`language`

`form`

`author`

`dateOfDocument`

`dateOfDocumentIso`

`ojCitation`

`legalStatus`

`latestConsolidatedVersion`

`numberOfPages`

`availableLanguages`

`matchedKeyword`

`documentHtmlText`

`scrapedAt`

# Actor input Schema

## `keywords` (type: `array`):

One or more EUR-Lex quick-search keywords, for example climate, digital services act, or procurement.

## `celexIds` (type: `array`):

Optional exact CELEX identifiers to fetch directly, such as 32021R1119 or 32022R2065.

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

Optional EUR-Lex search or document URLs. Use this when you already built an advanced EUR-Lex query in the browser.

## `language` (type: `string`):

EUR-Lex language code used for generated search and document links.

## `maxItems` (type: `integer`):

Maximum number of EUR-Lex document records to save.

## `dateFrom` (type: `string`):

Optional client-side lower bound for Date of document, in YYYY-MM-DD format.

## `dateTo` (type: `string`):

Optional client-side upper bound for Date of document, in YYYY-MM-DD format.

## `fetchDocumentHtml` (type: `boolean`):

Fetch each document HTML page and include a text excerpt. This is slower and costs more requests.

## Actor input object example

```json
{
  "keywords": [
    "climate"
  ],
  "celexIds": [],
  "startUrls": [],
  "language": "EN",
  "maxItems": 20,
  "fetchDocumentHtml": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "keywords": [
        "climate"
    ],
    "celexIds": [],
    "startUrls": [],
    "language": "EN",
    "maxItems": 20,
    "fetchDocumentHtml": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/eur-lex-eu-legislation-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "keywords": ["climate"],
    "celexIds": [],
    "startUrls": [],
    "language": "EN",
    "maxItems": 20,
    "fetchDocumentHtml": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/eur-lex-eu-legislation-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "climate"
  ],
  "celexIds": [],
  "startUrls": [],
  "language": "EN",
  "maxItems": 20,
  "fetchDocumentHtml": false
}' |
apify call automation-lab/eur-lex-eu-legislation-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/eur-lex-eu-legislation-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EUR-Lex EU Legislation Scraper",
        "description": "Scrape EUR-Lex EU legislation search results, CELEX identifiers, dates, document metadata, and official links.",
        "version": "0.1",
        "x-build-id": "FY3f5uPiUPimlRFPh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~eur-lex-eu-legislation-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-eur-lex-eu-legislation-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~eur-lex-eu-legislation-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-eur-lex-eu-legislation-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~eur-lex-eu-legislation-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-eur-lex-eu-legislation-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "One or more EUR-Lex quick-search keywords, for example climate, digital services act, or procurement.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "celexIds": {
                        "title": "CELEX IDs",
                        "type": "array",
                        "description": "Optional exact CELEX identifiers to fetch directly, such as 32021R1119 or 32022R2065.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "EUR-Lex search URLs",
                        "type": "array",
                        "description": "Optional EUR-Lex search or document URLs. Use this when you already built an advanced EUR-Lex query in the browser.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "BG",
                            "ES",
                            "CS",
                            "DA",
                            "DE",
                            "ET",
                            "EL",
                            "EN",
                            "FR",
                            "GA",
                            "HR",
                            "IT",
                            "LV",
                            "LT",
                            "HU",
                            "MT",
                            "NL",
                            "PL",
                            "PT",
                            "RO",
                            "SK",
                            "SL",
                            "FI",
                            "SV"
                        ],
                        "type": "string",
                        "description": "EUR-Lex language code used for generated search and document links.",
                        "default": "EN"
                    },
                    "maxItems": {
                        "title": "Maximum documents",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of EUR-Lex document records to save.",
                        "default": 20
                    },
                    "dateFrom": {
                        "title": "Document date from",
                        "type": "string",
                        "description": "Optional client-side lower bound for Date of document, in YYYY-MM-DD format."
                    },
                    "dateTo": {
                        "title": "Document date to",
                        "type": "string",
                        "description": "Optional client-side upper bound for Date of document, in YYYY-MM-DD format."
                    },
                    "fetchDocumentHtml": {
                        "title": "Fetch document HTML text",
                        "type": "boolean",
                        "description": "Fetch each document HTML page and include a text excerpt. This is slower and costs more requests.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```