# Autohome Car Listing (`truefetch/autohome-car-listing`) Actor

Search Autohome's public Mainland China vehicle catalog by keyword. Export normalized model, specification, price, manufacturer, image, and source-link fields.

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

## Pricing

from $5.48 / 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.

**Autohome Car Listing is a source-locked Mainland China vehicle catalog API that searches Autohome by make, model, or series keyword and publishes a normalized 35-field Dataset.**

- **Mainland China-only public country:** the focused input cannot route a run to unrelated international marketplaces.
- **Automatic Autohome source lock:** every focused run is restricted to the named catalog source.
- **Source-accurate catalog scope:** the adapter returns vehicle series and specification records, not a promise of live used-car inventory.
- **35 documented output fields:** unavailable source values remain empty instead of becoming inferred facts.

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

For the smallest controlled test, set `max_results` to `1` and budget at most $0.02250 on the FREE tier for one published result plus Actor Start. The public Store and API destinations were not live during the July 21, 2026 audit, so publication must be confirmed before launch.

### What does Autohome Car Listing do?

Autohome Car Listing submits a keyword to Autohome's public search service and normalizes qualifying vehicle series and specification responses. A record can contain a series name, specification or trim, guide price text, currency, model year, manufacturer, body structure, transmission, engine or displacement information, image, listing identifier, and a direct Autohome URL when those values are returned.

This is a catalog-oriented search surface. It must not be marketed as a guaranteed used-car inventory feed, dealer-lead database, VIN history service, or live transaction-price source. The source adapter reads official series/specification data, and many listing-oriented fields in the shared 35-field schema can therefore be empty.

The runtime now locks this focused Actor to Autohome before applying country and query-capability checks. Its public schema contains no platform selector, and input cannot broaden a run to Dongchedi. Global Car Listing remains the appropriate product for intentional multi-source China research.

The Actor is not affiliated with Autohome. Verify important facts on `source_url`, especially prices and specifications that may change after collection.

### How do I run Autohome Car Listing?

1. Open the [Autohome Car Listing input page](https://apify.com/truefetch/autohome-car-listing?fpr=aiagentapi).
2. Keep `country` set to `Mainland China` and enter a Chinese or source-recognized vehicle keyword such as `凯美瑞`.
3. Set `max_results` to `1` and start the Actor.
4. Confirm that `platform` is `Autohome`, then inspect `source_url` before increasing volume.

Every runnable example in this README uses this controlled input:

```json
{
  "country": "Mainland China",
  "keyword": "凯美瑞",
  "max_results": 1
}
````

The keyword is trimmed but not translated, expanded, or replaced. `max_results` is the Autohome run ceiling, not a promise that the source will return that many publishable records.

### What data does Autohome Car Listing return?

Each Dataset item follows a 35-field shared vehicle schema. Autohome catalog responses normally populate only the subset supported by a matched series or specification.

| Field group | Public fields | Meaning |
| --- | --- | --- |
| Vehicle identity | `title`, `year`, `make`, `model`, `trim`, `listing_id` | Series, specification, manufacturer, and source identifier. |
| Price | `price`, `currency`, `price_text` | Parsed or source-formatted guide price and CNY currency when supplied. |
| Specifications | `body_type`, `transmission`, `engine`, `fuel`, `drive_type`, `condition`, `mileage`, `mileage_unit`, `exterior_color`, `interior_color`, `vin` | Source-published details; unsupported values remain empty. |
| Images and text | `main_image`, `images`, `description` | Official image and combined catalog attributes when available. |
| Seller and market | `seller`, `seller_type`, `location`, `country`, `platform` | Manufacturer or factory context, country, and exact route attribution. |
| Links and dates | `source_url`, `platform_url`, `official_url`, `posted_at`, `updated_at` | Source traceability and dates when exposed. |
| Processing | `processor`, `processed_at` | Actor attribution and UTC processing timestamp. |

This abbreviated example illustrates the contract without claiming a live source response:

```json
{
  "title": "凯美瑞 2026款 双擎 2.0HGVP 豪华版",
  "price": 199800,
  "currency": "CNY",
  "year": 2026,
  "make": "丰田",
  "model": "凯美瑞",
  "trim": "双擎 2.0HGVP 豪华版",
  "body_type": "中型车",
  "transmission": "E-CVT",
  "country": "China",
  "platform": "Autohome",
  "source_url": "https://www.autohome.com.cn/spec/example/",
  "processor": "https://apify.com/username/actor_name",
  "processed_at": "2026-07-21T12:00:00Z"
}
```

Exports are available 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 | `Mainland China`, the only public market for this release. |
| `keyword` | string | Yes | A non-empty vehicle make, model, or series phrase sent without translation. |
| `max_results` | integer | Yes | From 1 to 10,000, applied to the source-locked Autohome run. |

Country, keyword, and max results form the complete public contract. Source selection is absent because the focused runtime enforces Autohome and does not accept a user override.

`location` is not exposed. The Autohome adapter uses a countrywide official search request with `cityid` set to zero and does not apply a user-supplied city as a native listing filter.

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

The public market is Mainland China. The named source is [Autohome search](https://sou.autohome.com.cn/), whose official search results can expose vehicle series and specification information. The adapter identifies records from Autohome, reports the record country as China, and preserves official destination URLs where available.

The focused runtime admits only the `autohome` route. Dongchedi remains available through Global Car Listing but is not selectable or reachable through this Actor.

This focused Actor does not cover other countries. Use [Global Car Listing](https://apify.com/truefetch/global-car-listing?fpr=aiagentapi) for multi-market research. Source response shapes, inventory, prices, and field completeness can change independently of the Actor.

### Why use Autohome Car Listing?

| Verified capability | Practical benefit |
| --- | --- |
| Automatic Autohome source lock | Keep the runnable platform set on the named route without a user filter. |
| Mainland China-focused input | Prevent accidental selection of unrelated international sources. |
| Normalized 35-field Dataset | Load repeat runs into stable columns even when fields are absent. |
| Direct official URLs | Review the vehicle series or specification page before acting. |
| Per-result billing | Relate most run cost to records actually written to the Dataset. |

The main trade-off is catalog scope: the Actor is source-specific, but it returns series/specification data rather than guaranteeing live used-car inventory.

### Who is Autohome Car Listing for?

Autohome Car Listing is intended for developers, automotive analysts, product researchers, catalog teams, and China-market data operations that need repeatable Autohome series/specification search. Typical uses include model discovery, guide-price sampling, trim comparison, manufacturer catalog review, search-result monitoring, source-link verification queues, and normalized exports for internal analysis.

It is not the right tool for buyers who require inspection results, verified transaction prices, ownership history, current dealer stock, contact enrichment, or every field shown on an Autohome page. Those tasks need independent sources and verification.

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

The intended owner/name identifier is `truefetch/autohome-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 integrating.

The current synchronous endpoint accepts the tilde-separated owner and Actor name:

```bash
curl -L "https://api.apify.com/v2/actors/truefetch~autohome-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": "Mainland China",
    "keyword": "凯美瑞",
    "max_results": 1
  }'
```

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

Apify currently 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 find `truefetch/autohome-car-listing`, inspect its schema, run the one-result `凯美瑞` scenario, and retrieve the Dataset item. Autohome is selected automatically. Running Actors requires authentication. See the [Apify MCP server guide](https://docs.apify.com/integrations/mcp).

### How much does Autohome Car Listing cost?

The Actor uses pay-per-event pricing. Actor Start is charged when a run begins, and one `result` event is charged for each 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.01250 | One published Dataset item. |
| Result - BRONZE | $0.01208 | One published Dataset item. |
| Result - SILVER | $0.01167 | One published Dataset item. |
| Result - GOLD | $0.01125 | One published Dataset item. |
| Result - PLATINUM | $0.01125 | One published Dataset item. |
| Result - DIAMOND | $0.01125 | One published Dataset item. |

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

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

| Option | Best fit | Trade-off |
| --- | --- | --- |
| Autohome Car Listing | Repeatable source-locked Autohome catalog search with normalized fields. | It is not a guaranteed live inventory feed. |
| Global Car Listing | Multi-country or multi-source automotive research. | Broader routing is unnecessary for an Autohome-only task. |
| Manual Autohome search | One-off research with full page context. | Difficult to schedule, export, or normalize repeatedly. |
| Dedicated Autohome integration | Teams requiring every source-specific field and workflow. | Higher maintenance and schema-mapping cost. |

Choose this Actor when normalized Autohome catalog records fit the workflow. Do not choose it as a substitute for a live used-car stock feed.

### What are the limits and troubleshooting steps?

| Symptom or limit | Explanation and next step |
| --- | --- |
| A result identifies Dongchedi or another source | Treat it as a source-lock regression; stop scaling and send the run ID plus source URL to support. |
| No dealer, mileage, or VIN data | The source route returns series/specification catalog records, not guaranteed used-car listings. |
| Input rejects another country | Mainland China is the only public country for this focused release. |
| Fewer records arrive than requested | `max_results` is a ceiling; the live search response determines publishable records. |
| Some normalized fields are empty | Autohome does not expose every shared vehicle field for every series/specification. |
| A source URL changes or disappears | Source pages can be updated after collection; rerun and treat older output as historical. |

For support, send the run ID, exact input, expected platform, and one public source URL. Never send 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 Dongchedi instead?

No. This focused Actor is locked to Autohome. Use Global Car Listing when Dongchedi or multi-source China coverage is required.

#### Does this return used-car listings?

The audited Autohome adapter returns official vehicle series and specification search records. It does not guarantee live used-car inventory.

#### Can I filter by city?

No. The public schema omits location because the adapter performs a countrywide Autohome catalog search.

#### Why are fields empty?

The 35-field schema is shared across vehicle sources, while an Autohome catalog record exposes only a subset.

#### Can I schedule the Actor?

Yes. Scheduled inputs use the same three fields, and the Actor remains source-locked to Autohome.

#### How is billing counted?

Each Dataset item triggers one result event; Actor Start is billed separately.

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

No. The user identified online data as old, and no current TrueFetch Store record was available during verification.

### Related TrueFetch Actors

- [Global Car Listing](https://apify.com/truefetch/global-car-listing?fpr=aiagentapi) is the correct choice for multi-country or multi-source automotive research.
- [CarDekho Car Listing](https://apify.com/truefetch/cardekho-car-listing?fpr=aiagentapi) focuses its public input on India vehicle sources.
- [Webmotors Car Listing](https://apify.com/truefetch/webmotors-car-listing?fpr=aiagentapi) focuses on Brazilian vehicle inventory research.

These related project directories were verified locally. Their public links must be checked again after publication.

### Support and last updated

- **Store:** [Autohome Car Listing](https://apify.com/truefetch/autohome-car-listing?fpr=aiagentapi)
- **API:** [Autohome Car Listing API](https://apify.com/truefetch/autohome-car-listing/api?fpr=aiagentapi)
- **Source:** [Autohome search](https://sou.autohome.com.cn/)
- **Apify 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 Autohome surface on **July 21, 2026**. Local Autohome-only routing now passes; unresolved Store/API links remain a publication gate.

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

# Actor input Schema

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

Mainland China is the only public market for this focused Actor.

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

Required vehicle make, model, or series phrase sent to the source without translation or replacement.

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

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

## Actor input object example

```json
{
  "country": "Mainland China",
  "keyword": "凯美瑞",
  "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": "Mainland China",
    "keyword": "凯美瑞",
    "max_results": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/autohome-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": "Mainland China",
    "keyword": "凯美瑞",
    "max_results": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/autohome-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": "Mainland China",
  "keyword": "凯美瑞",
  "max_results": 50
}' |
apify call truefetch/autohome-car-listing --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Autohome Car Listing",
        "description": "Search Autohome's public Mainland China vehicle catalog by keyword. Export normalized model, specification, price, manufacturer, image, and source-link fields.",
        "version": "1.0",
        "x-build-id": "aOZ5BvKUbM3XSBl0P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/truefetch~autohome-car-listing/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-truefetch-autohome-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~autohome-car-listing/runs": {
            "post": {
                "operationId": "runs-sync-truefetch-autohome-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~autohome-car-listing/run-sync": {
            "post": {
                "operationId": "run-sync-truefetch-autohome-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": [
                            "Mainland China"
                        ],
                        "type": "string",
                        "description": "Mainland China is the only public market for this focused Actor."
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Required vehicle make, model, or series phrase sent to the source without translation or replacement."
                    },
                    "max_results": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum normalized Autohome 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
