# Consulta de Veículo por Placa RENAVAM - Brasil / RENAVAM Lookup (`brasildados/consulta-veiculo-por-placa`) Actor

Consulta de Veículo por Placa RENAVAM Mercosul: pendências, chassi, marca, restrições, roubo/leilão/Renajud. Placa antiga/Mercosul. $1,20/sucesso, até 50, POST /check. | RENAVAM by plate: chassis, flags. Legacy/Mercosul. $1.20/success, max 50.

- **URL**: https://apify.com/brasildados/consulta-veiculo-por-placa.md
- **Developed by:** [BrasilDados.org](https://apify.com/brasildados) (community)
- **Categories:** Automation, Other, Integrations
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1,150.00 / 1,000 placa veicular consultada  / successful plate lookups

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

#### 🚗 O que é a Consulta de Veículo por Placa (RENAVAM por placa)?

**Consulta Veicular por Placa** é uma API de **consulta RENAVAM por placa** no Brasil: informe só a placa (antiga ou Mercosul) e receba **RENAVAM**, chassi, marca, modelo, restrições e indicadores de risco - **sem digitar o RENAVAM** na entrada. Até **50 placas** por execução, exporte **JSON, CSV, Excel ou XML** ou use o **Standby** (`POST /check`).

> **Uma placa na entrada = um registro na saída.** RENAVAM, chassi, marca, modelo, situação, restrições e indicadores (roubo/furto, leilão, Renajud, recall). Placa inválida gera erro local **sem cobrança**.

##### Quais dados a consulta extrai?

| | |
|---|---|
| 🆔 **Identificação** | `renavam`, `chassi`, `uf`, `municipio`, `placaFormatada` |
| 🚘 **Veículo** | `marca`, `modelo`, `anoModelo`, `anoFabricacao`, `cor`, `combustivel` |
| 📋 **Situação** | `situacaoVeiculo`, `anoExercicio` |
| ⚠️ **Restrições** | `restricoes[]` (sem duplicar "SEM RESTRIÇÃO") |
| 🚨 **Indicadores** | `rouboFurto`, `leilao`, `renajud`, `recall`, `renainf`, `alarme` |
| 🔒 **LGPD** | `proprietarioMascarado`, `documentoProprietarioMascarado` (sem CPF/CNPJ ou nome completo) |

##### O que este Actor faz?

- 🚗 **Consulta por placa:** padrão antigo e **Mercosul**, com ou sem traço
- 🔄 **Normalização automática:** `ABC-1234`, `ABC 1D23` e `ABC1D23` viram o mesmo formato interno
- 📤 **Lote:** até **50 placas** por execução no Console
- ⚡ **API Standby:** `POST /check` para CRM, seguros e antifraude em tempo real
- 💰 **Cobrança justa:** só placa com `encontrado: true` (**$1,20** por sucesso)

**Bônus Apify:** agendar monitoramentos, webhooks, API e integração MCP.

---

### Por que consultar veículo por placa?

- **Due diligence automotiva:** validar cadastro antes de compra ou financiamento
- **Seguros e corretoras:** checagem rápida de restrições e indicadores de risco
- **Antifraude:** cruzar placa com roubo/furto, leilão e Renajud
- **Frotas:** auditoria em lote de placas ativas
- **Integrações:** JSON estruturado pronto para ERP, TMS ou data lake

---

### Como consultar placas em lote?

1. Abra o actor no [Console Apify](https://console.apify.com/) na aba **Input**.
2. Cole as placas na lista **`placas`** (uma por linha). Misture antigas e Mercosul à vontade.
3. Clique em **Start** e exporte o Dataset em **JSON**, **CSV** ou **XLSX**.

**Exemplo de entrada:**

```json
{
  "placas": ["ABC1D23", "ABC-1234", "ODT-7H70"]
}
````

> **Dica:** o actor normaliza traço, espaço e pontuação antes de consultar.

***

#### 📐 Formatos de placa aceitos

| Padrão | Sem separador | Com traço (opcional) |
|---|---|---|
| **Antigo** | `ABC1234` | `ABC-1234` |
| **Mercosul** | `ABC1D23` | `ABC-1D23` |

Fora desses padrões → item com `erro` local, **sem cobrança**.

***

#### ⬇️ Entrada

| Campo | Obrigatório | Padrão | Descrição |
|---|---|---|---|
| `placas` | ✅ Sim | `["ABC1D23"]` | Lista de placas (antigo ou Mercosul). Máx. **50** |

***

#### ⬆️ Saída

Baixe na aba **Dataset** em JSON, CSV, Excel ou XML. Um registro por placa. Nome do proprietário e CPF/CNPJ saem sempre **mascarados** (LGPD).

```json
{
  "placaConsultada": "ABC1D23",
  "placaFormatada": "ABC-1D23",
  "encontrado": true,
  "consultadoEm": "2026-06-03T12:00:00.000Z",
  "referenciaConsulta": "bd-a1b2c3d4e5f6",
  "anoExercicio": "2024",
  "proprietarioMascarado": "J*** S***",
  "documentoProprietarioMascarado": "***425***-**",
  "veiculo": {
    "renavam": "12345678901",
    "placa": "ABC1D23",
    "placaFormatada": "ABC-1D23",
    "chassi": "9BR123ABC123456789",
    "uf": "SP",
    "municipio": "São Paulo",
    "marca": "VOLKSWAGEN",
    "modelo": "GOL 1.0",
    "anoModelo": "2024",
    "anoFabricacao": "2023",
    "situacaoVeiculo": "ATIVA",
    "combustivel": "GASOHOL",
    "cor": "BRANCA",
    "restricoes": ["RENAJUD"],
    "indicadores": {
      "rouboFurto": false,
      "leilao": false,
      "renajud": true,
      "recall": false,
      "renainf": false,
      "alarme": false
    },
    "faturado": null
  },
  "erro": null
}
```

**Lista completa de campos:** aba **Dataset schema** no Console Apify (todos os campos, tipos e descrições).

***

#### 💰 Quanto custa a consulta por placa?

**$1,20 por consulta bem-sucedida** (`encontrado: true`), evento `consulta-placa-veicular`. Cobra só quando o veículo é encontrado.

| Placas encontradas | Custo |
|---|---|
| 1 | $1,20 |
| 10 | $12,00 |
| 50 (máx/execução) | $60,00 |

Placa inválida ou sem retorno na base **não** dispara o evento. Na janela 23:00-03:00 (horário de Brasília), falha sem dados também não cobra.

> Consulta indisponível das 23:00 às 03:00 (horário de Brasília) por manutenção do portal de origem. Nenhuma cobrança é aplicada neste período. Tente novamente após as 03:00.

***

#### 🔌 Integração via API

**Execução em lote:**

```bash
curl -X POST "https://api.apify.com/v2/acts/brasildados~consulta-veiculo-por-placa/runs?token=SEU_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"placas":["ABC1D23","ABC-1234"]}'
```

**Standby (`POST /check`):**

```bash
curl -X POST "https://brasildados--consulta-veiculo-por-placa.apify.actor/check" \
  -H "Authorization: Bearer SEU_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  --compressed \
  -d '{"placas":["ABC1D23","ABC-1234"]}'
```

***

### Actors relacionados

| Actor | Quando usar |
|---|---|
| [Enriquecimento CNPJ](https://apify.com/brasildados/brazil-enrich-data-lead-by-cnpj?fpr=t5lwzq) | Dados cadastrais completos por CNPJ |
| [KYC & PEP Checker](https://apify.com/brasildados/cnpj-kyc-compliance-pep-checker?fpr=t5lwzq) | PEP, sanções e doações eleitorais |
| [Consulta de Sanções](https://apify.com/brasildados/sanctions-check?fpr=t5lwzq) | Sanções CEIS/CNEP por CPF/CNPJ |

***

### Perguntas frequentes

#### Consigo ver as restrições do veículo pela placa? Quais aparecem?

Sim. A saída inclui `restricoes[]` com as restrições ativas e o objeto `indicadores` com sinalizadores de risco: roubo ou furto (`rouboFurto`), leilão (`leilao`), bloqueio judicial Renajud (`renajud`), recall, multas Renainf (`renainf`) e alarme.

#### Como saber se um carro é roubado ou foi de leilão pela placa?

`indicadores.rouboFurto` indica registro de roubo ou furto e `indicadores.leilao` indica que o veículo passou por leilão. Ambos vêm como `true`/`false` em cada consulta.

#### Dá para consultar o RENAVAM e o chassi só com a placa?

Sim. Informe apenas a placa, sem o RENAVAM. A saída retorna RENAVAM, chassi, marca, modelo, ano, cor, combustível e UF/município de emplacamento dentro de `veiculo`.

#### A consulta funciona com placa Mercosul e placa antiga?

Sim. Aceita o padrão antigo (`ABC1234` / `ABC-1234`) e o Mercosul (`ABC1D23` / `ABC-1D23`). A placa é normalizada automaticamente.

#### A consulta mostra o nome do dono do veículo pela placa?

Por conformidade com a LGPD, o nome do proprietário e o documento (CPF/CNPJ) são retornados mascarados (ex.: `J*** S***`, `***425***-**`). A API foca nos dados do veículo, nas restrições e nos indicadores de risco.

#### A API cobra se a placa não existe ou não retorna dados?

Não. A cobrança de $1,20 só ocorre em consulta bem-sucedida (`encontrado: true`). Placa inválida, inexistente ou sem retorno não gera cobrança.

***

### 🇺🇸 English version

#### 🚗 RENAVAM lookup by license plate

**Vehicle Plate Lookup** returns **RENAVAM**, chassis, make, model, restrictions and risk flags for any Brazilian **license plate** - legacy or Mercosul. Send only the plate (no RENAVAM upfront) and get a clean record per plate. Up to **50 plates** per run, export **JSON, CSV, Excel or XML**, or use the **Standby** REST API (`POST /check`).

> **One plate in = one record out.** RENAVAM, chassis, make, model, status, restrictions and risk flags (theft, auction, Renajud, recall). Invalid plates return a local error **with no charge**.

##### Plate formats (auto-normalized)

| Pattern | Plain | With hyphen |
|---|---|---|
| **Legacy** | `ABC1234` | `ABC-1234` |
| **Mercosul** | `ABC1D23` | `ABC-1D23` |

##### Pricing

**$1.20 per successful lookup** (`encontrado: true`), event `consulta-placa-veicular`. Pay only when the vehicle is found. Max **50 plates** per run. Invalid or not-found plates are never billed. During the 11:00 p.m.-3:00 a.m. (Brasília time) upstream maintenance window, an empty result is not charged either.

##### API integration

**Batch run:**

```bash
curl -X POST "https://api.apify.com/v2/acts/brasildados~consulta-veiculo-por-placa/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"placas":["ABC1D23","ABC-1234"]}'
```

**Standby (`POST /check`):**

```bash
curl -X POST "https://brasildados--consulta-veiculo-por-placa.apify.actor/check" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  --compressed \
  -d '{"placas":["ABC1D23","ABC-1234"]}'
```

##### FAQ

**Can I see the vehicle's restrictions by plate?** Yes - `restricoes[]` plus the `indicadores` object with risk flags: theft (`rouboFurto`), auction (`leilao`), judicial block Renajud (`renajud`), recall, fines (`renainf`) and alarm.

**Can I get RENAVAM and chassis from the plate only?** Yes. Send only the plate; the output returns RENAVAM, chassis, make, model, year, color, fuel and emplacement UF/municipality inside `veiculo`.

**Does it work with Mercosul and legacy plates?** Yes, both, with or without hyphen. The plate is normalized automatically.

**Does it show the owner's name?** Owner name and document (CPF/CNPJ) are masked for LGPD compliance (e.g. `J*** S***`).

**Are invalid or not-found plates charged?** No. The $1.20 charge applies only to successful lookups (`encontrado: true`).

The full field schema and the JSON output sample are shown in the Portuguese section above (see **Saída**), and on the **Dataset schema** tab.

***

[Apify Store - brasildados/consulta-veiculo-por-placa](https://apify.com/brasildados/consulta-veiculo-por-placa?fpr=t5lwzq)

# Actor input Schema

## `placas` (type: `array`):

Placas para **consulta RENAVAM** (só a placa na entrada). **Antigo:** `ABC1234` ou `ABC-1234`. **Mercosul:** `ABC1D23` ou `ABC-1D23`. Traço/espaço normalizados. Inválidas: erro local, sem cobrança. Máx. 50. | Plates for **RENAVAM lookup** (plate only, no RENAVAM input). Legacy and Mercosul. Hyphen optional. Max 50.

## Actor input object example

```json
{
  "placas": [
    "ABC1D23",
    "ABC-1234",
    "ODT-7H70"
  ]
}
```

# Actor output Schema

## `resultados` (type: `string`):

URL da API Apify para baixar os itens do dataset.

# 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 = {
    "placas": [
        "ABC1D23",
        "ABC-1234",
        "ODT-7H70"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("brasildados/consulta-veiculo-por-placa").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 = { "placas": [
        "ABC1D23",
        "ABC-1234",
        "ODT-7H70",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("brasildados/consulta-veiculo-por-placa").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 '{
  "placas": [
    "ABC1D23",
    "ABC-1234",
    "ODT-7H70"
  ]
}' |
apify call brasildados/consulta-veiculo-por-placa --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=brasildados/consulta-veiculo-por-placa",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Consulta de Veículo por Placa RENAVAM - Brasil / RENAVAM Lookup",
        "description": "Consulta de Veículo por Placa RENAVAM Mercosul: pendências, chassi, marca, restrições, roubo/leilão/Renajud. Placa antiga/Mercosul. $1,20/sucesso, até 50, POST /check. | RENAVAM by plate: chassis, flags. Legacy/Mercosul. $1.20/success, max 50.",
        "version": "1.0",
        "x-build-id": "b9jJhDq0r9GKHNJPw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/brasildados~consulta-veiculo-por-placa/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-brasildados-consulta-veiculo-por-placa",
                "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/brasildados~consulta-veiculo-por-placa/runs": {
            "post": {
                "operationId": "runs-sync-brasildados-consulta-veiculo-por-placa",
                "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/brasildados~consulta-veiculo-por-placa/run-sync": {
            "post": {
                "operationId": "run-sync-brasildados-consulta-veiculo-por-placa",
                "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": [
                    "placas"
                ],
                "properties": {
                    "placas": {
                        "title": "Placas / License plates",
                        "minItems": 1,
                        "maxItems": 50,
                        "type": "array",
                        "description": "Placas para **consulta RENAVAM** (só a placa na entrada). **Antigo:** `ABC1234` ou `ABC-1234`. **Mercosul:** `ABC1D23` ou `ABC-1D23`. Traço/espaço normalizados. Inválidas: erro local, sem cobrança. Máx. 50. | Plates for **RENAVAM lookup** (plate only, no RENAVAM input). Legacy and Mercosul. Hyphen optional. Max 50.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
