# Goldstandard Credits Search Scraper (`stealth_mode/goldstandard-credits-search-scraper`) Actor

Scrape the Gold Standard carbon credits registry to collect detailed credit issuance data. This scraper extracts 30+ fields per credit block—including certification dates, vintage years, transferability status, and compliance flags—essential for climate finance professionals, investors.

- **URL**: https://apify.com/stealth\_mode/goldstandard-credits-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Gold Standard Credits Search Scraper: Extract Carbon Credits Registry Data

---

### What Is Gold Standard?

Gold Standard is an internationally recognized certification standard for climate action projects. Its registry (registry.goldstandard.org) maintains a comprehensive database of verified carbon credits issued by certified projects worldwide. These credits represent real, measurable greenhouse gas reductions and removals. For investors, traders, analysts, and sustainability teams, accessing this credit data at scale is critical—but manually searching the registry is slow and inefficient. The **Gold Standard Credits Search Scraper** automates this process, delivering structured credit block data ready for analysis, compliance tracking, and trading workflows.

---

### Overview

The **Gold Standard Credits Search Scraper** extracts detailed credit block records from the Gold Standard registry, turning search results into clean, machine-readable datasets. It is designed for:

- **Carbon traders** and portfolio managers tracking credit availability and status
- **Climate finance analysts** researching project performance and credit validity
- **Sustainability consultants** building compliance reports and offset inventories
- **Researchers** studying global carbon credit markets and project trends
- **Enterprise platforms** aggregating ESG and carbon offset data

Key strengths include configurable pagination support, graceful error handling for failed URLs, and granular control over scraping volume. The scraper can handle multiple search pages and extract all relevant credit metadata in a single run.

---

### Input Format

The scraper accepts a JSON configuration object controlling URLs, pagination, and fault tolerance:

```json
{
  "ignore_url_failures": true,
  "max_items_per_url": 200,
  "urls": [
    "https://registry.goldstandard.org/credit-blocks/issuances?q=&page=1"
  ]
}
````

| Parameter | Type | Description |
|---|---|---|
| `urls` | array | Direct links to Gold Standard registry credit search pages. Supports pagination parameters (e.g., `?page=1`, `?page=2`). Use the Bulk edit feature to add multiple URLs at once. |
| `max_items_per_url` | integer | Maximum number of credit records to extract per URL. Default: `20`. Higher values (e.g., `200`) collect more credits per page but increase processing time. |
| `ignore_url_failures` | boolean | If `true`, the scraper continues running if some URLs fail (network errors, timeouts). If `false`, a single failed URL stops the entire run. Recommended: `true` for batch operations. |

**Best practices:**

- For broad searches, use multiple URLs covering different pages or filter criteria
- Adjust `max_items_per_url` based on your system capacity (typically 50–200 for production runs)
- Always enable `ignore_url_failures` when scraping 10+ URLs to ensure reliability

***

### Output Format & Field Definitions

**Example output record:**

```json
{
  "id": "585521",
  "created_at": "2026-06-04T15:18:34Z",
  "updated_at": "2026-06-04T15:20:55Z",
  "number_of_credits": 2199,
  "starting_credit_number": 1,
  "ending_credit_number": 2199,
  "batch_number": 30431,
  "serial_number": "GS1-1-BF-GS11989-16-2023-30431-1-2199",
  "certified_date": "2026-06-04",
  "monitoring_period_start_date": "2023-01-01",
  "monitoring_period_end_date": "2023-12-31",
  "status": "ISSUED",
  "vintage": "2023",
  "is_active": false,
  "is_transferable": false,
  "is_retirable": false,
  "is_assignable": false,
  "is_convertable": false,
  "is_cancelable": false,
  "is_flagged_for_transactional_approval": false,
  "is_note_displayable": false,
  "is_using_entity_displayable": false,
  "is_undo_issuable": false,
  "is_undo_assignable": false,
  "is_undo_retirable": false,
  "is_corsia_eligible": false,
  "project": {
    "id": "3964",
    "created_at": "2023-02-07T17:23:45Z",
    "updated_at": "2026-06-04T15:28:59Z",
    "name": "GS1340 - Efficient cookstoves in Burkina Faso – tiipaalga F3PA cookstoves in Center-South Protected Areas - VPA-47",
    "description": "The continuous degradation of natural resources (soil, vegetation, water resources, etc.) in the Center-South region of Burkina Faso leads to an increase in household poverty and food insecurity. Based on its experience and achievements with the improved three-stone cookstoves, tiipaalga is aiming to promote the distribution of the F3PA or the 3 stones improved cookstoves around the Center-South Protected Areas. This micro-scale VPA is part of a group of 10 VPA’s aiming to contribute to mitigating the effects of climate change and reduce poverty among rural households by promoting the use of the F3PA improved cookstoves in two (02) rural municipalities in Nahouri province and in five (05) rural municipalities in Zoundwéogo province in the Center-South region. The F3PA wood stoves will replace the traditional open air three stone cooking method whilst respecting the local three stone cooking culture.",
    "status": "GOLD_STANDARD_CERTIFIED_PROJECT",
    "gsf_standards_version": "Gold Standard for the Global Goals",
    "estimated_annual_credits": 9700,
    "crediting_period_start_date": "2023-01-01",
    "crediting_period_end_date": "2027-12-31",
    "methodology": null,
    "type": "Energy Efficiency - Domestic",
    "size": "Micro Scale",
    "sustaincert_id": 11989,
    "sustaincert_url": "https://assurance-platform.goldstandard.org/project-documents/GS11989",
    "project_developer": "Tiipaalga",
    "carbon_stream": "GS_VER",
    "country": "Burkina Faso",
    "country_code": "BF",
    "latitude": null,
    "longitude": null,
    "state": null,
    "crediting_periods": null,
    "programme_of_activities": "VPA",
    "poa_project_id": 1431,
    "poa_project_sustaincert_id": 1340,
    "poa_project_name": "Efficient Cookstoves in Burkina Faso (PoA)",
    "labels": [
      "EMISSION_REDUCTION"
    ]
  },
  "product": {
    "name": "Verified Emission Reduction",
    "abbreviation": "VER"
  },
  "labels": [
    "EMISSION_REDUCTION"
  ],
  "from_url": "https://registry.goldstandard.org/credit-blocks/issuances?q=&page=1"
}
```

Each credit block record includes 30+ fields capturing full issuance history, compliance status, and transactional capabilities:

#### Identity & Timestamps

| Field | Meaning | Example |
|---|---|---|
| `ID` | Unique internal identifier for the credit block in Gold Standard's system | `12345` |
| `Created At` | Timestamp when the credit block was first created in the registry | `2023-06-15T10:30:00Z` |
| `Updated At` | Most recent modification date for this credit record | `2024-01-20T14:22:15Z` |

#### Credit Quantity & Serial Tracking

| Field | Meaning | Example |
|---|---|---|
| `Number Of Credits` | Total count of carbon credits in this block (1 credit = 1 tonne CO₂e) | `50000` |
| `Starting Credit Number` | First credit serial number in the range | `1000001` |
| `Ending Credit Number` | Last credit serial number in the range | `1050000` |
| `Batch Number` | Unique batch identifier for this issuance | `BATCH-2023-045` |
| `Serial Number` | Sequential number assigned during issuance | `GS-2023-045-001` |

#### Project & Certification Timeline

| Field | Meaning | Example |
|---|---|---|
| `Project` | Name and link to the originating climate project | `"Renewable Energy Project Kenya"` |
| `Product` | Credit type under Gold Standard (e.g., VER, CORSIA) | `"Gold Standard VER"` |
| `Certified Date` | Date when the credits were officially certified by Gold Standard | `2023-06-10` |
| `Monitoring Period Start Date` | Beginning of the monitoring period for emission reductions | `2023-01-01` |
| `Monitoring Period End Date` | End of the monitoring period for this issuance | `2023-12-31` |
| `Vintage` | Vintage year (when reductions occurred); critical for eligibility | `2023` |

#### Lifecycle & Status Flags

| Field | Meaning | Impact |
|---|---|---|
| `Status` | Current state of the credit block (e.g., issued, pending, retired) | Determines tradability and use |
| `Is Active` | Boolean: credit block is currently active and eligible for trading | `true` or `false` |
| `Is Transferable` | Boolean: credits can be transferred between accounts | `true` = tradable |
| `Is Retirable` | Boolean: credits can be retired (removed from circulation) as offsets | `true` = usable for compliance |
| `Is Assignable` | Boolean: credits can be assigned to beneficiaries or projects | `true` = flexible ownership |
| `Is Convertable` | Boolean: credits can be converted into alternative forms or standards | `true` = conversion eligible |
| `Is Cancelable` | Boolean: credits can be permanently canceled by the holder | `true` = destruction possible |

#### Approval & Display Controls

| Field | Meaning | Use Case |
|---|---|---|
| `Is Flagged For Transactional Approval` | Boolean: credit block requires additional review before trading | Compliance risk indicator |
| `Is Note Displayable` | Boolean: associated notes are visible to registry users | Transparency flag |
| `Is Using Entity Displayable` | Boolean: the using entity (buyer/retirer) is publicly shown | Privacy and transparency control |

#### Undo & Operational Flags

| Field | Meaning | Scenario |
|---|---|---|
| `Is Undo Issuable` | Boolean: credits can be re-issued if issuance is reversed | Post-issuance correction |
| `Is Undo Assignable` | Boolean: assignment can be undone in case of error | Transaction reversal |
| `Is Undo Retirable` | Boolean: retirement can be reversed if incorrectly applied | Audit correction |

#### Regulatory & Classification

| Field | Meaning | Impact |
|---|---|---|
| `Is Corsia Eligible` | Boolean: credits meet ICAO CORSIA eligibility requirements | Airline offset eligibility |
| `Labels` | Array of tags or categories (e.g., sustainable development goals, co-benefits) | SDG alignment, market positioning |

***

### How to Use

1. **Locate registry URLs** — Navigate to registry.goldstandard.org/credit-blocks/issuances and apply filters (project name, vintage year, status). Copy the full search URL including query parameters.
2. **Configure the input** — Paste URLs into the `urls` array. For multi-page results, add separate URLs for each page (e.g., `?page=1`, `?page=2`).
3. **Set limits** — Adjust `max_items_per_url` based on your bandwidth. Start with `100–200` for balanced performance.
4. **Enable fault tolerance** — Set `ignore_url_failures: true` to handle network interruptions gracefully.
5. **Run the scraper** — Start the actor and monitor progress in the run log.
6. **Export and analyze** — Download results as JSON, CSV, or Excel. Filter, sort, and integrate into your carbon accounting system.

**Common scenarios:**

- **Tracking a project's credits:** Search the registry for a specific project name, copy the result URL, and scrape all credit blocks issued by that project.
- **Vintage-based analysis:** Use Gold Standard's filter tools to isolate credits from a specific vintage year, then scrape the filtered results.
- **CORSIA compliance:** Filter for CORSIA-eligible credits and scrape to build a compliant offset portfolio.

***

### Use Cases & Business Value

- **Portfolio management:** Track credit holdings by status, vintage, and transferability in real time
- **Market intelligence:** Monitor credit issuance volumes and trends across projects and geographies
- **Compliance reporting:** Automatically generate detailed credit inventories for regulatory filings
- **Trading workflows:** Extract actionable credit data (serial numbers, dates, eligibility flags) for transactions
- **Carbon accounting:** Integrate structured credit data into enterprise ESG platforms and sustainability software
- **Academic research:** Analyze patterns in global carbon credit issuance, project performance, and standard evolution

By automating data extraction, this scraper eliminates manual registry browsing and ensures data accuracy across investment, compliance, and reporting teams.

***

### Conclusion

The **Gold Standard Credits Search Scraper** is the go-to solution for accessing verified carbon credits data at scale. With comprehensive field coverage—from credit quantities and vintage years to compliance flags and transactional controls—it empowers traders, analysts, and sustainability teams to make faster, more informed decisions. Whether you're tracking portfolio movements, building market intelligence, or automating compliance workflows, this scraper delivers the clean, structured data you need.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the credits search urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://registry.goldstandard.org/credit-blocks/issuances?q=&page=1"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://registry.goldstandard.org/credit-blocks/issuances?q=&page=1"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/goldstandard-credits-search-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 = {
    "urls": ["https://registry.goldstandard.org/credit-blocks/issuances?q=&page=1"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/goldstandard-credits-search-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 '{
  "urls": [
    "https://registry.goldstandard.org/credit-blocks/issuances?q=&page=1"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/goldstandard-credits-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=stealth_mode/goldstandard-credits-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Goldstandard Credits Search Scraper",
        "description": "Scrape the Gold Standard carbon credits registry to collect detailed credit issuance data. This scraper extracts 30+ fields per credit block—including certification dates, vintage years, transferability status, and compliance flags—essential for climate finance professionals, investors.",
        "version": "0.0",
        "x-build-id": "IIR68afYWohlvVJ7K"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~goldstandard-credits-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-goldstandard-credits-search-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/stealth_mode~goldstandard-credits-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-goldstandard-credits-search-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/stealth_mode~goldstandard-credits-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-goldstandard-credits-search-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": {
                    "urls": {
                        "title": "URLs of the credits search urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the credits search urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
