# sgCarMart Vehicle Search (`agentx/sgcarmart-vehicle-search`) Actor

Search public sgCarMart used-car inventory in Singapore by keyword. Export normalized SGD prices, make, model, mileage, fuel, transmission, seller, images, and source URLs.

- **URL**: https://apify.com/agentx/sgcarmart-vehicle-search.md
- **Developed by:** [AgentX](https://apify.com/agentx) (community)
- **Categories:** E-commerce, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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 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

**sgCarMart Vehicle Search is a Singapore used-car listings API for keyword research, returning source-linked prices, vehicle attributes, seller context, and images in one normalized 35-field Dataset.**

- **Singapore-focused input:** the public country cannot route to unrelated international markets.
- **Automatic sgCarMart source lock:** every focused run is restricted to the named marketplace.
- **Used-car inventory scope:** search results can expose SGD price, make, model, mileage, fuel, transmission, body type, seller, and image.
- **35 documented fields:** absent source values remain empty instead of becoming inferred facts.

[**Run a one-result test**](https://apify.com/agentx/sgcarmart-vehicle-search) · [**View the API page**](https://apify.com/agentx/sgcarmart-vehicle-search/api)

For the smallest controlled test, use `Toyota`, set `max_results` to `1`, and budget at most $0.01850 on the FREE tier for one published result plus Actor Start. Verify the source page before using a price or seller detail. Local sgCarMart-only routing now passes; the Store/API pages were not live on July 21, 2026 and remain a publication gate.

### Why Choose This API

#### Focused Singapore vehicle discovery

sgCarMart Vehicle Search submits a make, model, or related phrase to public sgCarMart used-car inventory and publishes normalized records. When present in a qualifying result, the Actor can return a vehicle title, SGD asking price, make, model, mileage, fuel type, transmission, body type, seller name, image, Singapore attribution, platform name, and source URL.

The public schema permits only Singapore and does not expose a platform selector. The runtime resolves this Actor to sgCarMart before country and query checks, so input cannot broaden a run to Motorist.sg. Use All Vehicle Scraper when multi-source Singapore research is intentional.

#### Normalized output with source provenance

One Dataset structure makes repeated exports easier to compare. Different sgCarMart results may expose different subsets, so unsupported fields remain empty. Use `source_url` to confirm a listing's current price, availability, seller copy, COE context, registration details, and any source-native field not represented in the normalized output.

This Actor is not affiliated with sgCarMart. It is not a vehicle inspection, valuation guarantee, ownership-history service, financing offer, contact-enrichment database, or certification product. Listings can change after collection.

### Quick Start Guide

#### Run a source-controlled test

1. Open [sgCarMart Vehicle Search](https://apify.com/agentx/sgcarmart-vehicle-search).
2. Keep `country` set to `Singapore` and enter a keyword such as `Toyota`.
3. Set `max_results` to `1` and start the Actor.
4. Confirm that `platform` is `sgCarMart`, then inspect `source_url`.

Use this same scenario in the Console and integrations:

```json
{
  "country": "Singapore",
  "keyword": "Toyota",
  "max_results": 1
}
````

The keyword is trimmed but not translated, expanded, or replaced. `max_results` is the source-locked sgCarMart run ceiling, not a guarantee that the live source will return that count. This focused public form does not expose location because the current sgCarMart search does not apply a user-supplied location.

### Input Parameters

#### Configuration fields

| Parameter | Type | Required | Accepted value and behavior |
| --- | --- | --- | --- |
| `country` | string | Yes | `Singapore`, the only public country for this focused Actor. |
| `keyword` | string | Yes | A non-empty vehicle make, model, or search phrase. |
| `max_results` | integer | Yes | 1 to 10,000; maximum records returned by the source-locked sgCarMart run. |

Country, keyword, and max results are the complete public input contract. Source selection is absent because the focused runtime enforces sgCarMart and user input cannot override it.

#### Why there is no location field

Singapore is the only market, and the current source request is keyword-based. A generic location input would not become a native sgCarMart filter and could cause all compatible routes to be skipped. Removing that control avoids a misleading Store form.

### Output Data Schema

#### Complete normalized record

Each result uses 33 normalized vehicle fields plus `processor` and `processed_at`, for 35 fields total.

| Field group | Fields |
| --- | --- |
| Identity | `title`, `listing_id`, `vin`, `description` |
| Images | `main_image`, `images` |
| Price | `price`, `currency`, `price_text` |
| Vehicle | `year`, `make`, `model`, `trim`, `condition`, `body_type`, `fuel`, `transmission`, `engine`, `drive_type`, `exterior_color`, `interior_color` |
| Mileage | `mileage`, `mileage_unit` |
| Seller and market | `seller`, `seller_type`, `location`, `country`, `platform` |
| Links and dates | `source_url`, `platform_url`, `official_url`, `posted_at`, `updated_at` |
| Processing | `processor`, `processed_at` |

This abbreviated example illustrates the contract and is not a current live listing:

```json
{
  "main_image": "https://example.com/sgcarmart/toyota-corolla.jpg",
  "title": "Toyota Corolla Altis 1.6A Elegance",
  "price": 80888,
  "currency": "SGD",
  "make": "Toyota",
  "model": "Corolla Altis",
  "mileage": 50000,
  "mileage_unit": "km",
  "fuel": "Petrol",
  "transmission": "Automatic",
  "seller": "Example dealer",
  "country": "Singapore",
  "platform": "sgCarMart",
  "source_url": "https://www.sgcarmart.com/used-cars/info/example",
  "processor": "https://apify.com/username/actor_name",
  "processed_at": "2026-07-21T12:00:00Z"
}
```

Values such as depreciation, registration date, COE expiry, engine capacity, owner count, or financing copy may appear on the source but are not promised as dedicated normalized fields. Current export formats are documented by the [Dataset items API](https://docs.apify.com/api/v2/dataset-items-get).

### Integration Examples

#### REST API

The intended owner/name identifier is `agentx/sgcarmart-vehicle-search`. The public Store API returned no current record for that identifier on July 21, 2026, so no numeric Actor ID, rating, user count, or old online statistic is presented as current evidence.

After publication, run the same one-result scenario synchronously:

```bash
curl -L "https://api.apify.com/v2/actors/agentx~sgcarmart-vehicle-search/run-sync-get-dataset-items?maxItems=1" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -d '{
    "country": "Singapore",
    "keyword": "Toyota",
    "max_results": 1
  }'
```

Review the official [synchronous Actor endpoint](https://docs.apify.com/api/v2/act-run-sync-get-dataset-items-post) for current authentication, timeout, response, and charge-limit options.

#### MCP

Apify documents a hosted Streamable HTTP MCP server:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=actors,docs"
    }
  }
}
```

After publication, ask the MCP client to locate `agentx/sgcarmart-vehicle-search`, inspect the schema, run the Toyota scenario, and return the Dataset item. sgCarMart is selected automatically. Authentication is required to run Actors. See the [Apify MCP guide](https://docs.apify.com/integrations/mcp).

#### Workflow integrations

Apify schedules, webhooks, Make, n8n, and client SDKs can consume the same three-field input after publication. Scheduled runs remain source-locked to sgCarMart. Verify Actor identity in the current integration picker instead of using an unverified numeric ID.

### Pricing & Cost Calculator

sgCarMart Vehicle Search uses pay-per-event pricing. Actor Start is charged when a run begins, and one `result` event is charged for every item written to the default Dataset.

| Billed event and tier | Price per event | Billing unit |
| --- | ---: | --- |
| Actor Start | $0.01000 | One Actor run start. |
| Result - FREE | $0.00850 | One published Dataset item. |
| Result - BRONZE | $0.00822 | One published Dataset item. |
| Result - SILVER | $0.00793 | One published Dataset item. |
| Result - GOLD | $0.00765 | One published Dataset item. |
| Result - PLATINUM | $0.00765 | One published Dataset item. |
| Result - DIAMOND | $0.00765 | One published Dataset item. |

On the FREE tier, one published result costs $0.01000 + $0.00850 = **$0.01850**. An empty run can still incur Actor Start. Each sgCarMart item written to the default Dataset creates one `result` event. Confirm live pricing after publication.

### Use Cases & Applications

#### Singapore inventory and price research

Collect repeat samples for makes and models, compare SGD asking prices and mileage, and retain source URLs for validation. Treat price as a listing value at collection time, not an independent valuation.

#### Dealer and listing monitoring

Create internal review queues for newly observed listings, seller names, or inventory changes when those values are public. Respect source terms and do not treat a seller field as consent for marketing or contact enrichment.

#### Data pipelines and analysis

Load normalized records into spreadsheets, databases, dashboards, search indexes, or internal AI-assisted research. Preserve nullable values and source provenance. Independent verification remains necessary for purchase, financing, insurance, or safety decisions.

#### Alternatives

Use All Vehicle Scraper when multi-country or multi-source comparison is intentional. Browse sgCarMart manually for a one-off purchase decision that needs full page context. Use an authorized data feed when contractual completeness or every Singapore-specific field is required.

### FAQ

#### Which inputs are required?

`country`, `keyword`, and `max_results` are required. No platform selector is exposed.

#### Can I select Motorist.sg instead?

No. This focused Actor is locked to sgCarMart. Use All Vehicle Scraper for Motorist.sg or multi-source Singapore research.

#### Can I filter by Singapore district?

Not with the current public schema. The audited source search is keyword-based and does not apply a user location.

#### Does the Actor return COE and depreciation fields?

Only if source text maps into an existing normalized field. Dedicated COE and depreciation columns are not promised.

#### Why are some fields empty?

Individual sgCarMart results do not expose all 35 normalized fields. The Actor does not invent missing values.

#### Does `max_results` guarantee that many records?

No. Live inventory, page availability, unique source identity, and publishable results determine the count.

#### Can I schedule runs?

Yes after publication. Scheduled inputs use the same three fields and remain source-locked to sgCarMart.

#### How is billing counted?

One result event is charged per Dataset item, plus the separate Actor Start event.

### Trust & Data Quality

- **Source traceability:** public sgCarMart links support independent review.
- **Stable output contract:** the Dataset and overview both expose 35 fields.
- **Transparent optionality:** source values that are absent remain empty.
- **Current evidence discipline:** old online data is separated from current local and official-source verification.
- **Source-lock regression gate:** a record attributed to any platform other than sgCarMart is treated as a defect.

For a reproducible support case, send the run ID, exact input, expected platform, and one public source URL. Never send API tokens or private data.

### Legal & Compliance

sgCarMart Vehicle Search is intended for lawful analysis of publicly accessible vehicle listings. Users are responsible for applicable laws, source terms, privacy rules, intellectual-property rights, data retention, and contractual restrictions. Do not use output for unlawful profiling, discrimination, fraud, unauthorized resale, or access to non-public data.

Verify vehicle condition, registration, COE, seller identity, price, and financing information independently before making a decision. The Actor does not certify a vehicle or seller.

### Related Tools

#### Vehicle research

- [All Vehicle Scraper](https://apify.com/agentx/all-vehicle-scraper) supports intentional multi-country and multi-source vehicle research.
- [Cars Vehicle Search](https://apify.com/agentx/cars-vehicle-search) focuses on Cars.com inventory in the United States.
- [Auto Trader UK Vehicle Search](https://apify.com/agentx/auto-trader-uk-vehicle-search) focuses on UK listings with a required runtime location.

#### Enrichment and workflow tools

- [Google Maps Store Scraper](https://apify.com/agentx/google-maps-store-scraper) supports separate public business research.
- [All Shopping Scraper](https://apify.com/agentx/all-shopping-scraper) supports product and retail comparisons.
- [All Jobs Scraper](https://apify.com/agentx/all-jobs-scraper) supports multi-platform job workflows.

The related project directories were verified locally. Each Store link must be rechecked after publication.

### Support & Community

- **Store:** [sgCarMart Vehicle Search](https://apify.com/agentx/sgcarmart-vehicle-search)
- **API:** [sgCarMart Vehicle Search API](https://apify.com/agentx/sgcarmart-vehicle-search/api)
- **Official source:** [sgCarMart used-car listings](https://www.sgcarmart.com/used-cars/listing)
- **Platform help:** [Apify documentation](https://docs.apify.com/)
- **Community:** [Apify Actor Telegram](https://t.me/Apify_Actor)
- **Direct support:** [AiAgentApi support](https://t.me/AiAgentApi)

Verified against local schemas, pricing metadata, source-lock regression evidence, and the current public sgCarMart surface on **July 21, 2026**. Local sgCarMart-only routing now passes; unresolved Store/API links remain a publication gate.

[**Run a one-result sgCarMart test**](https://apify.com/agentx/sgcarmart-vehicle-search) · [**Review the API page**](https://apify.com/agentx/sgcarmart-vehicle-search/api)

# Actor input Schema

## `country` (type: `string`):

Singapore is the only public market for this focused Actor.

## `keyword` (type: `string`):

Required vehicle make, model, or search phrase sent without translation or replacement.

## `max_results` (type: `integer`):

Maximum sgCarMart records returned. This is a ceiling, not guaranteed inventory.

## Actor input object example

```json
{
  "country": "Singapore",
  "keyword": "Toyota",
  "max_results": 50
}
```

# Actor output Schema

## `results` (type: `string`):

Open the overview table for normalized vehicle listings from the selected supported platforms.

# 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 = {
    "country": "Singapore",
    "keyword": "Toyota",
    "max_results": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/sgcarmart-vehicle-search").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 = {
    "country": "Singapore",
    "keyword": "Toyota",
    "max_results": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("agentx/sgcarmart-vehicle-search").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 '{
  "country": "Singapore",
  "keyword": "Toyota",
  "max_results": 50
}' |
apify call agentx/sgcarmart-vehicle-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "sgCarMart Vehicle Search",
        "description": "Search public sgCarMart used-car inventory in Singapore by keyword. Export normalized SGD prices, make, model, mileage, fuel, transmission, seller, images, and source URLs.",
        "version": "1.0",
        "x-build-id": "g2tdVgRffFjUvnHvC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/agentx~sgcarmart-vehicle-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-agentx-sgcarmart-vehicle-search",
                "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/agentx~sgcarmart-vehicle-search/runs": {
            "post": {
                "operationId": "runs-sync-agentx-sgcarmart-vehicle-search",
                "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/agentx~sgcarmart-vehicle-search/run-sync": {
            "post": {
                "operationId": "run-sync-agentx-sgcarmart-vehicle-search",
                "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": [
                    "country",
                    "keyword",
                    "max_results"
                ],
                "properties": {
                    "country": {
                        "title": "🌍 Country",
                        "enum": [
                            "Singapore"
                        ],
                        "type": "string",
                        "description": "Singapore is the only public market for this focused Actor."
                    },
                    "keyword": {
                        "title": "🔍 Keyword",
                        "type": "string",
                        "description": "Required vehicle make, model, or search phrase sent without translation or replacement."
                    },
                    "max_results": {
                        "title": "📊 Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum sgCarMart records returned. This is a ceiling, not guaranteed inventory."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
