# Verra Carbon Project Registry Scraper (`automation-lab/verra-carbon-project-registry-scraper`) Actor

🌿 Extract normalized Verra VCS project details, status, methodology, reductions, validators, public-comment dates, participation data, and grouped documents from IDs or URLs.

- **URL**: https://apify.com/automation-lab/verra-carbon-project-registry-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 25.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Verra Carbon Project Registry Scraper

Extract detailed Verra VCS carbon project records from project IDs or public registry URLs.

Get normalized project status, methodology, proponent, estimated annual reductions, buffer credits, location, validator, registration and crediting dates, public-comment periods, participation programs, and grouped public documents.

Use the actor for one-off due diligence or schedule a portfolio refresh to detect changes in Verra registry records.

### What does Verra Carbon Project Registry Scraper do?

The actor turns each supplied Verra project ID into one structured dataset record.

It reads Verra's public project resource and preserves both convenient normalized fields and variable registry attributes.

🌿 Fetch VCS project details by numeric ID.

🔗 Accept public Verra project-detail URLs.

📄 Return grouped document names, types, dates, and links.

📊 Normalize reductions, methodology, status, area, and validator.

🧩 Preserve VCS and CCB participation blocks for advanced analysis.

No Verra login, browser automation, or proxy configuration is required.

### Who is it for?

**Carbon-credit buyers** can refresh shortlisted projects before procurement reviews.

**Project developers** can verify how their public registry records appear in downstream systems.

**Climate-finance analysts** can assemble comparable project profiles without copying fields by hand.

**Due-diligence teams** can collect validation reports, monitoring reports, and public-comment dates.

**Data platforms** can enrich internal carbon-project records with Verra source links and source codes.

**Researchers** can export selected VCS records to JSON, CSV, Excel, or a database.

### Why use this Verra project scraper?

A Verra project page contains useful information across project metadata, program participation, and document groups.

Manual collection is slow and inconsistent when a portfolio contains many project IDs.

This actor provides:

- one stable row per unique Verra project ID;
- predictable normalized field names;
- nested source detail when programs differ;
- direct links back to the public registry;
- retries for temporary registry errors;
- duplicate removal before requests;
- API, schedule, webhook, and export support from Apify.

### Supported Verra URLs and IDs

Use a numeric ID:

```json
{
  "projectIds": ["2250"]
}
````

Or use a public VCS project URL:

```json
{
  "projectIds": [
    "https://registry.verra.org/app/projectDetail/VCS/2250"
  ]
}
```

The public JSON resource URL is also accepted:

```text
https://registry.verra.org/uiapi/resource/resourceSummary/2250
```

URLs from other hosts and non-VCS project routes are rejected to prevent accidental off-target scraping.

### What Verra carbon project data can I extract?

| Field | Description |
|---|---|
| `projectId` | Verra registry project identifier |
| `name` | Public project name |
| `description` | Project description from Verra |
| `status` | Primary VCS project status |
| `proponent` | Project proponent name |
| `projectType` | Primary project category |
| `projectSubtypes` | Semicolon-delimited source subtypes as an array |
| `methodology` | Protocol or methodology code |
| `estimatedAnnualReductions` | Estimated annual emission reductions |
| `totalBufferPoolCredits` | Reported buffer-pool credits |
| `stateProvince` | State or province |
| `latitude`, `longitude` | Public project coordinates |
| `validator` | Validation or verification body |
| `registrationDate` | Registry registration date |
| `creditingPeriod` | Source crediting-period text |
| `documentGroups` | Grouped public project documents |
| `participationSummaries` | VCS, CCB, and other program attributes |

### Input

The input has two fields.

#### `projectIds`

Required array of one to 100 values.

Each value must be:

- a numeric Verra project ID;
- a public `registry.verra.org/app/projectDetail/VCS/...` URL; or
- a public `registry.verra.org/uiapi/resource/resourceSummary/...` URL.

Duplicate IDs are fetched once.

#### `maxConcurrency`

Optional integer from 1 to 10.

The default is 5.

Lower the value if you prefer a slower registry refresh.

### Example input

```json
{
  "projectIds": [
    "2250",
    "https://registry.verra.org/app/projectDetail/VCS/4834",
    "1000"
  ],
  "maxConcurrency": 3
}
```

This creates up to three project records.

### Output

Results are stored in the default Apify dataset.

A shortened record looks like this:

```json
{
  "projectId": "2250",
  "projectUrl": "https://registry.verra.org/app/projectDetail/VCS/2250",
  "name": "Delta Blue Carbon – 1",
  "stateProvince": "Sindh",
  "status": "Registered",
  "proponent": "Multiple Proponents",
  "projectType": "Agriculture Forestry and Other Land Use",
  "projectSubtypes": ["ARR", "WRC"],
  "methodology": "VM0033",
  "estimatedAnnualReductions": 2407629,
  "totalBufferPoolCredits": 575431,
  "projectArea": "350000 Hectares",
  "documentGroups": [
    {
      "code": "VCS_REGISTRATION_DOCUMENTS",
      "name": "VCS Registration Documents",
      "documents": []
    }
  ],
  "scrapedAt": "2026-07-22T00:00:00.000Z"
}
```

Optional fields are omitted when Verra does not publish them.

### Public project documents

`documentGroups` keeps Verra's document organization.

Each group contains:

- source group code;
- human-readable group name;
- document name;
- document type;
- upload date;
- public document URL.

Typical groups include pipeline, registration, issuance, validation, verification, and other documents.

The actor returns document metadata and links; it does not download PDF or spreadsheet bodies.

### Participation summaries and raw attributes

Verra records can participate in more than one program.

For example, one project may expose VCS and CCB blocks with different statuses or attributes.

`participationSummaries` preserves every observed program code and its typed attribute values.

`rawAttributes` preserves project-level source codes.

Use normalized top-level fields for common analysis and raw blocks for source-specific research.

### How much does it cost to scrape Verra carbon projects?

The actor uses pay-per-event pricing.

A small one-time Start event covers run setup.

A Project record event is charged only for each project successfully saved to the dataset.

| Apify tier | Start | Per project record |
|---|---:|---:|
| Free | $0.005 | $0.00016677 |
| Bronze | $0.005 | $0.00014502 |
| Silver | $0.005 | $0.00011312 |
| Gold | $0.005 | $0.000087013 |
| Platinum | $0.005 | $0.000058009 |
| Diamond | $0.005 | $0.000040606 |

Failed or missing project IDs do not create project-record charges.

Apify displays your exact tier price before a run starts.

Higher subscription tiers receive automatic per-record discounts.

Use a small list first to estimate the cost for your portfolio.

### How to run the actor

1. Open the actor on Apify.
2. Add one or more Verra project IDs or URLs.
3. Keep the default concurrency for most portfolios.
4. Click **Start**.
5. Review the **Verra projects** dataset view.
6. Export results as JSON, CSV, Excel, XML, or RSS.

The prefilled ID provides a low-cost first run.

### Portfolio monitoring workflow

Create an Apify schedule to refresh important projects daily or weekly.

Store each run's dataset in your warehouse.

Compare records by `projectId`.

Track changes to fields such as:

- `status`;
- `inPublicCommentPeriod`;
- `publicCommentStart` and `publicCommentEnd`;
- `validator`;
- `registrationDate`;
- document names and upload dates.

Use a webhook to trigger your comparison job when a run finishes.

### Data quality and failure handling

The actor validates all targets before making requests.

Temporary network failures, HTTP 429 responses, and server errors receive bounded retries with backoff.

A missing project is logged and skipped when other valid projects succeed.

If every requested project fails, the run fails instead of returning a misleading successful empty dataset.

Each output row includes `sourceApiUrl`, `projectUrl`, and `scrapedAt` for traceability.

### Tips for reliable extraction

- Keep project IDs as strings so leading formatting is not changed by spreadsheets.
- Use the default concurrency unless you have a reason to tune it.
- Deduplication is automatic within a run.
- Schedule repeat runs outside peak internal processing windows when possible.
- Compare document URLs and upload dates rather than relying only on document names.
- Preserve raw participation blocks in your data warehouse for future schema changes.
- Test your downstream mapping with projects from different categories and programs.

### Integrations

Connect the dataset to Google Sheets for an analyst review queue.

Send records to Airtable for project screening and ownership.

Load JSON into BigQuery, Snowflake, or PostgreSQL for portfolio history.

Use Make or Zapier to notify a diligence channel when a run completes.

Call the actor from an internal credit-procurement service before an approval meeting.

Use Apify webhooks to launch document-diff or status-change processing.

### API usage with JavaScript

Install the Apify client:

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

Run the actor:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/verra-carbon-project-registry-scraper').call({
  projectIds: ['2250', '4834'],
  maxConcurrency: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

Install the client:

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

Run and read records:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/verra-carbon-project-registry-scraper').call(
    run_input={'projectIds': ['2250'], 'maxConcurrency': 1}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

Start a synchronous run and return dataset items:

```bash
curl "https://api.apify.com/v2/acts/automation-lab~verra-carbon-project-registry-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"projectIds":["2250"],"maxConcurrency":1}'
```

Keep tokens in environment variables, not source code.

### Use with Apify MCP

Connect the actor to AI assistants through Apify MCP.

Use this MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/verra-carbon-project-registry-scraper
```

#### Claude Code setup

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/verra-carbon-project-registry-scraper" --header "Authorization: Bearer $APIFY_TOKEN"
```

#### Claude Desktop setup

#### Cursor setup

#### VS Code setup

Claude Desktop, Cursor, and VS Code can use the following remote MCP configuration. Replace the environment placeholder through your client's secure secret settings.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/verra-carbon-project-registry-scraper",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}
```

Example prompts:

- “Extract Verra project 2250 and summarize its methodology and validator.”
- “Compare the statuses and annual reductions for Verra projects 1000 and 4834.”
- “List newly uploaded public documents for this saved Verra portfolio.”

### Scheduling and webhooks

Apify schedules can run the same project portfolio repeatedly.

Choose a frequency that matches your diligence process.

Attach a run-succeeded webhook to notify a service or automation platform.

The receiving service can fetch the dataset using `defaultDatasetId`.

For change detection, store the previous successful record keyed by `projectId`.

### Is it legal to scrape the Verra registry?

The actor reads publicly accessible project metadata and public document links.

Your use must comply with applicable laws, Verra's terms, database rights, and privacy obligations.

Do not use the output to misrepresent project quality, credit ownership, or verification status.

Public availability does not remove your responsibility to assess licensing and permitted reuse.

This actor is an independent extraction tool and is not affiliated with or endorsed by Verra.

### Limitations

Version 1 requires supplied project IDs or URLs.

It does not promise registry-wide discovery or keyword search.

It does not download or parse document contents.

It does not calculate credit prices, ownership, issuance inventory, retirement balances, or project ratings.

Source fields may be absent or change when Verra updates a record or its API.

The normalized primary fields prefer the VCS participation block when available.

### Troubleshooting

#### Why was a project skipped?

Check the run log for a 404 or source error.

Confirm the project exists at a public VCS project-detail URL and that its numeric ID is correct.

#### Why is a field missing?

Verra does not publish every attribute for every project.

Inspect `participationSummaries` and `rawAttributes` to see the complete source blocks returned for that record.

#### Why did the whole run fail?

The run fails when all targets fail validation or extraction.

Fix invalid IDs or URLs and rerun with one known public project first.

### FAQ

#### Can I mix IDs and URLs?

Yes. The actor normalizes both formats and removes duplicate IDs.

#### Does it require a Verra account?

No. The supported project-detail resource is public.

#### Does it use a proxy?

No proxy is required for the current public JSON route.

#### Can I scrape CCB details?

When a project exposes a CCB participation block, it is preserved in `participationSummaries`.

#### Can I monitor project changes?

Yes. Schedule repeat runs and compare rows by `projectId`.

#### Are document files downloaded?

No. The dataset contains public document metadata and links.

### Related scrapers

Explore other data actors from [automation-lab](https://apify.com/automation-lab) for complementary due-diligence and public-data workflows.

Use this actor when you already know the Verra VCS project IDs you need and want deep project-detail records.

For cross-source enrichment, combine its dataset with other automation-lab actors through Apify datasets, webhooks, API clients, or MCP.

### Support

If a valid public Verra VCS project produces an incomplete or failed record, open an issue from the actor's Apify page.

Include the project ID, run URL, and the field you expected.

Do not include private credentials or confidential procurement data.

Source structures can change, so concrete examples help us update normalization quickly.

# Actor input Schema

## `projectIds` (type: `array`):

One to 100 numeric project IDs or public registry.verra.org VCS project-detail URLs. Duplicate IDs are fetched once.

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

Number of Verra project records fetched at the same time. Keep the default for reliable registry access.

## Actor input object example

```json
{
  "projectIds": [
    "2250"
  ],
  "maxConcurrency": 5
}
```

# Actor output Schema

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

Open the normalized Verra projects produced by this run.

# 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 = {
    "projectIds": [
        "2250"
    ],
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/verra-carbon-project-registry-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 = {
    "projectIds": ["2250"],
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/verra-carbon-project-registry-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 '{
  "projectIds": [
    "2250"
  ],
  "maxConcurrency": 5
}' |
apify call automation-lab/verra-carbon-project-registry-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Verra Carbon Project Registry Scraper",
        "description": "🌿 Extract normalized Verra VCS project details, status, methodology, reductions, validators, public-comment dates, participation data, and grouped documents from IDs or URLs.",
        "version": "0.1",
        "x-build-id": "JiXs9NNWo9BwgjT6M"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~verra-carbon-project-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-verra-carbon-project-registry-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~verra-carbon-project-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-verra-carbon-project-registry-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~verra-carbon-project-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-verra-carbon-project-registry-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",
                "required": [
                    "projectIds"
                ],
                "properties": {
                    "projectIds": {
                        "title": "🌿 Verra project IDs or URLs",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "One to 100 numeric project IDs or public registry.verra.org VCS project-detail URLs. Duplicate IDs are fetched once.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "2250"
                        ]
                    },
                    "maxConcurrency": {
                        "title": "⚙️ Maximum concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of Verra project records fetched at the same time. Keep the default for reliable registry access.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```