# CarDekho Car Listing (`truefetch/cardekho-car-listing`) Actor

Search public CarDekho vehicle listings in India by keyword. Export 35 normalized fields covering price, specifications, images, sellers, location, and source URLs.

- **URL**: https://apify.com/truefetch/cardekho-car-listing.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** E-commerce, Lead generation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.03 / 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

> **Affiliate disclosure:** Apify Store links in this README use the `fpr=aiagentapi` referral parameter, which may attribute a signup or purchase without changing your price.

**CarDekho Car Listing is a source-locked India vehicle listings API that searches CarDekho by keyword and returns a normalized 35-field Dataset.**

- **India-only public country:** the input cannot route this focused release to an unrelated market.
- **Automatic CarDekho source lock:** every run is restricted to the named marketplace before routing begins.
- **Three public inputs:** country, keyword, and an Actor-wide result ceiling.
- **35 documented output fields:** unavailable source values stay empty instead of becoming inferred facts.

[**Run a one-result test**](https://apify.com/truefetch/cardekho-car-listing?fpr=aiagentapi) · [**View API**](https://apify.com/truefetch/cardekho-car-listing/api?fpr=aiagentapi)

For the smallest safe test, set `max_results` to `1` and budget at most $0.02200 on the FREE tier for one result plus Actor Start.

### What does CarDekho Car Listing do?

CarDekho Car Listing accepts an India vehicle keyword, searches public [CarDekho used-car listings](https://www.cardekho.com/usedcars), and publishes normalized records. It can return INR price, make, model, year, mileage, fuel, transmission, body type, image, country, platform, and source URL when those values are present.

The runtime now locks this focused Actor to CarDekho before country compatibility and query-capability checks are applied. The public schema exposes no platform selector, and an input payload cannot broaden the run to CARS24, CarWale, or another India route. Global Car Listing remains the separate multi-platform product.

The Actor is not affiliated with CarDekho. It is not a vehicle inspection, ownership history, valuation guarantee, financing service, or private seller database. Open `source_url` and independently verify important listing facts.

### How do I run CarDekho Car Listing?

1. Open the [CarDekho Car Listing input page](https://apify.com/truefetch/cardekho-car-listing?fpr=aiagentapi).
2. Keep `country` set to `India` and enter a make/model phrase such as `Hyundai Creta`.
3. Set `max_results` to `1` and start the Actor.
4. Verify that the returned `platform` is `CarDekho` and review `source_url` before increasing volume.

Every runnable example below uses this same scenario:

```json
{
  "country": "India",
  "keyword": "Hyundai Creta",
  "max_results": 1
}
````

`max_results` is the CarDekho run's practical result ceiling. It is a maximum, not guaranteed inventory, and the live source can return fewer unique publishable records.

### What data does CarDekho Car Listing return?

Each published item follows one 35-field schema. CarDekho may expose a useful subset for a listing, while unsupported or absent values remain empty.

| Field group | Public fields | Meaning |
| --- | --- | --- |
| Listing identity | `title`, `listing_id`, `vin`, `description` | Source title, text, and identifiers when present. |
| Images | `main_image`, `images` | Primary image and image collection when available. |
| Price | `price`, `currency`, `price_text` | Parsed amount, source currency, and formatted price text. |
| Vehicle identity | `year`, `make`, `model`, `trim`, `condition` | Model-year and vehicle identity values. |
| Specifications | `mileage`, `mileage_unit`, `body_type`, `fuel`, `transmission`, `engine`, `drive_type`, `exterior_color`, `interior_color` | Odometer and source-published specification details. |
| Seller and market | `seller`, `seller_type`, `location`, `country`, `platform` | Seller context, geography, and exact source attribution. |
| Links and dates | `source_url`, `platform_url`, `official_url`, `posted_at`, `updated_at` | Listing traceability and source timestamps. |
| Processing | `processor`, `processed_at` | Actor attribution and processing time. |

This abbreviated, illustrative record matches the Hyundai Creta scenario:

```json
{
  "main_image": "https://example.com/cardekho/hyundai-creta.jpg",
  "title": "Hyundai Creta 2021",
  "price": 1425000,
  "currency": "INR",
  "year": 2021,
  "make": "Hyundai",
  "model": "Creta",
  "mileage": 23000,
  "fuel": "Petrol",
  "transmission": "Automatic",
  "body_type": "SUV",
  "country": "India",
  "platform": "CarDekho",
  "source_url": "https://www.cardekho.com/used-car-details/example",
  "processor": "https://apify.com/username/actor_name",
  "processed_at": "2026-07-21T12:00:00Z"
}
```

Apify Datasets can be exported through the formats supported by the current [Dataset items API](https://docs.apify.com/api/v2/dataset-items-get), including JSON, JSONL, CSV, Excel, XML, HTML, and RSS.

### What inputs can I configure?

| Input | Type | Required | Accepted value and effect |
| --- | --- | --- | --- |
| `country` | string | Yes | `India`, the only public country for this release. |
| `keyword` | string | Yes | A non-empty vehicle phrase sent without translation or replacement. |
| `max_results` | integer | Yes | From 1 to 10,000, applied to the source-locked CarDekho run. |

Country, keyword, and max results are the complete public input contract. Source selection is deliberately absent because the Actor identity enforces CarDekho and user input cannot override it.

The public schema does not expose `location` because the current CarDekho request path does not apply a verified user-supplied location filter.

### What platforms and markets does CarDekho Car Listing cover?

The public market is India. The named source, CarDekho, publishes used-car listings with price, mileage, transmission, fuel, images, and city or seller context when available. The Actor preserves source values and normalizes the fields it can verify.

The focused runtime admits only the `cardekho` route for this Actor. CARS24 and CarWale remain available through Global Car Listing but are not selectable or reachable here.

This Actor does not cover other countries or global marketplaces. For multi-country selection, use [Global Car Listing](https://apify.com/truefetch/global-car-listing?fpr=aiagentapi). Source availability, listing count, and field completeness can change independently of the Actor.

### Why use CarDekho Car Listing?

| Verified capability | Practical benefit |
| --- | --- |
| Automatic CarDekho source lock | Keep the runnable platform set on the named marketplace without a user-supplied filter. |
| India-focused schema | Prevent accidental country routing to unrelated international sources. |
| Normalized 35-field Dataset | Load repeated runs into stable columns even when some values are absent. |
| Direct listing URLs | Review the original CarDekho page before trusting a commercial or pricing decision. |
| Per-result billing | Relate most of the Actor cost to records written to the Dataset. |

The main trade-off is source specialization: it provides a stable normalized contract but does not expose every native CarDekho field or offer cross-market comparison inside the same run.

### Who is CarDekho Car Listing for?

CarDekho Car Listing is intended for developers, automotive analysts, India dealer researchers, pricing teams, inventory monitors, and data operations specialists. Typical tasks include used-car asking-price samples, make/model availability checks, inventory snapshots, source-link review queues, and repeatable exports for internal dashboards.

It does not replace an inspection, valuation, ownership report, private contact enrichment service, or source-specific feed that guarantees every native CarDekho field. Use Global Car Listing instead when several India sources should be queried together.

### How can I use CarDekho Car Listing through the API or MCP?

The canonical owner/name identifier derived from this release is `truefetch/cardekho-car-listing`. The public Store API did not return a current record for that identifier on July 21, 2026, so a numeric Actor ID and live Store proof are intentionally omitted. Verify publication before using these Actor-specific destinations.

The current Apify API accepts a numeric Actor ID or a tilde-separated owner and Actor name. This synchronous example uses the complete three-field public input:

```bash
curl -L "https://api.apify.com/v2/actors/truefetch~cardekho-car-listing/run-sync-get-dataset-items?maxItems=1" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -d '{
    "country": "India",
    "keyword": "Hyundai Creta",
    "max_results": 1
  }'
```

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

Apify currently recommends its hosted Streamable HTTP MCP server:

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

After publication, ask the MCP client to find `truefetch/cardekho-car-listing`, inspect the schema, run the one-result Hyundai Creta scenario, and retrieve the Dataset item. The runtime selects CarDekho automatically. Running Actors requires authentication. See the current [Apify MCP server guide](https://docs.apify.com/integrations/mcp).

### How much does CarDekho Car Listing cost?

The Actor uses pay-per-event pricing. Actor Start is charged once when a run begins, and `result` is charged for every record 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.01200 | One published Dataset item. |
| Result - BRONZE | $0.01160 | One published Dataset item. |
| Result - SILVER | $0.01120 | One published Dataset item. |
| Result - GOLD | $0.01080 | One published Dataset item. |
| Result - PLATINUM | $0.01080 | One published Dataset item. |
| Result - DIAMOND | $0.01080 | One published Dataset item. |

On the FREE tier, one published CarDekho result costs $0.01000 + $0.01200 = **$0.02200**. An empty run can still incur Actor Start. Each CarDekho record written to the default Dataset creates one `result` event. Verify live Store pricing after publication.

### How does CarDekho Car Listing compare with alternatives?

| Option | Best fit | Trade-off |
| --- | --- | --- |
| CarDekho Car Listing | Repeatable source-locked CarDekho research using normalized fields. | Native fields that are absent from source results remain empty. |
| Global Car Listing | Cross-market or multi-source automotive analysis. | Broader scope is unnecessary for a CarDekho-only job. |
| Manual CarDekho browsing | One-off review with full source-page context. | Difficult to schedule, export, or compare repeatedly. |
| Dedicated native integration | Teams requiring every CarDekho-specific field. | More maintenance and normalization work. |

Choose this Actor for CarDekho-only work. Choose Global Car Listing when the intended workflow needs multiple India marketplaces in one run.

### What are the limits and troubleshooting steps?

| Symptom or limit | Explanation and next step |
| --- | --- |
| A result identifies another platform | Treat it as a source-lock regression; stop scaling the run and send the run ID plus source URL to support. |
| Input rejects another country | India is the only public country for this focused release. |
| No location field is available | The public schema omits location to avoid silently routing a CarDekho-named run to a different source. |
| Fewer records arrive than requested | `max_results` is a ceiling; live CarDekho inventory and publishable fields determine actual output. |
| Optional fields are empty | CarDekho does not expose every normalized field on every listing. Verify `source_url`. |
| A listing link no longer opens | Source listings can be edited or removed after collection. Rerun and treat the old record as historical. |

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

### Frequently asked questions

#### Which inputs are required?

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

#### Can I select another India platform?

No. This focused Actor is locked to CarDekho. Use Global Car Listing for CARS24, CarWale, or multi-source India searches.

#### How is CarDekho kept separate from other India routes?

The focused Actor resolves to one platform before route compatibility checks, and its public schema contains no platform override. A result attributed to another marketplace is a defect rather than expected fallback behavior.

#### Can I filter by city?

Not on the current public schema. Location was removed to prevent misleading cross-source fallback behavior.

#### Why are some fields empty?

The 35-field schema is normalized across vehicle sources, while individual CarDekho listings expose only a subset.

#### How is billing counted?

One `result` event is charged per CarDekho Dataset item. Actor Start is separate.

#### Can I schedule this Actor?

Yes. Scheduled inputs use the same three-field contract, and the Actor remains source-locked to CarDekho.

#### Are legacy Store statistics used as proof?

No. The user identified online data as old, and the public TrueFetch record was unavailable during verification.

### Related TrueFetch Actors

- [Global Car Listing](https://apify.com/truefetch/global-car-listing?fpr=aiagentapi) is the honest choice for multi-country or multi-source vehicle research.
- [28car Car Listing](https://apify.com/truefetch/28car-car-listing?fpr=aiagentapi) focuses on Hong Kong, where the country route resolves to one source.
- [Webmotors Car Listing](https://apify.com/truefetch/webmotors-car-listing?fpr=aiagentapi) focuses on Brazilian vehicle inventory and pricing research.

These three related project directories were verified locally. Their public links must be rechecked after publication.

### Support and last updated

- **Store:** [CarDekho Car Listing](https://apify.com/truefetch/cardekho-car-listing?fpr=aiagentapi)
- **API:** [CarDekho Car Listing API](https://apify.com/truefetch/cardekho-car-listing/api?fpr=aiagentapi)
- **Source:** [CarDekho used cars](https://www.cardekho.com/usedcars)
- **Apify platform help:** [Apify documentation](https://docs.apify.com/)
- **Community:** [TrueFetch Telegram group](https://t.me/TrueFetch)
- **Direct support:** [AiAgentApi support](https://t.me/AiAgentApi)

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

[**Test one CarDekho result**](https://apify.com/truefetch/cardekho-car-listing?fpr=aiagentapi) · [**Review the API surface**](https://apify.com/truefetch/cardekho-car-listing/api?fpr=aiagentapi)

# Actor input Schema

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

India market used for source routing and proxy selection.

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

Required vehicle search phrase. It is sent without adding, removing, translating, or replacing terms.

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

Maximum CarDekho vehicle listings returned.

## Actor input object example

```json
{
  "country": "India",
  "keyword": "Hyundai Creta",
  "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": "India",
    "keyword": "Hyundai Creta",
    "max_results": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/cardekho-car-listing").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": "India",
    "keyword": "Hyundai Creta",
    "max_results": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/cardekho-car-listing").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": "India",
  "keyword": "Hyundai Creta",
  "max_results": 50
}' |
apify call truefetch/cardekho-car-listing --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=truefetch/cardekho-car-listing",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CarDekho Car Listing",
        "description": "Search public CarDekho vehicle listings in India by keyword. Export 35 normalized fields covering price, specifications, images, sellers, location, and source URLs.",
        "version": "1.0",
        "x-build-id": "osJh7AM9R7yIiMB7P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/truefetch~cardekho-car-listing/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-truefetch-cardekho-car-listing",
                "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/truefetch~cardekho-car-listing/runs": {
            "post": {
                "operationId": "runs-sync-truefetch-cardekho-car-listing",
                "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/truefetch~cardekho-car-listing/run-sync": {
            "post": {
                "operationId": "run-sync-truefetch-cardekho-car-listing",
                "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": [
                            "India"
                        ],
                        "type": "string",
                        "description": "India market used for source routing and proxy selection."
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Required vehicle search phrase. It is sent without adding, removing, translating, or replacing terms."
                    },
                    "max_results": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum CarDekho vehicle listings returned."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
