# AutoTrader Vehicle Search (`agentx/autotrader-vehicle-search`) Actor

Search public Autotrader US vehicle inventory by keyword and optional ZIP radius. Export normalized listing titles, prices, source links, and other available vehicle fields.

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

## Pricing

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

**AutoTrader Vehicle Search is a United States Autotrader listings API for keyword and optional ZIP-radius discovery, publishing source-linked vehicle results in one normalized 35-field Dataset.**

- **US-only public market:** the focused country input prevents accidental international routing.
- **Automatic Autotrader US source lock:** every focused run is restricted to the intended marketplace.
- **Optional ZIP-radius request:** a resolved US postal code applies a 50-mile Autotrader search radius.
- **Verifiable output:** each publishable record carries source attribution, with unsupported fields left empty.

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

For a controlled first run, search `Toyota Camry` around `90001`, set `max_results` to `1`, and budget at most $0.01900 on the FREE tier for one result plus Actor Start. Open `source_url` before acting on a listing. Local Autotrader-only routing now passes; the Store/API destinations were not live on July 21, 2026 and remain a publication gate.

### Why Choose This API

#### Focused Autotrader discovery

AutoTrader Vehicle Search sends a vehicle phrase to public Autotrader US inventory and publishes qualifying vehicle links. Search results can provide a source title, asking-price text, normalized numeric price, USD currency, country attribution, platform name, and direct vehicle URL. Other shared vehicle fields are populated only when the source response exposes values that can be verified.

The public schema restricts the country to the United States and does not expose a platform selector. The runtime resolves this Actor to Autotrader US before country and location checks, so input cannot broaden a run to any of the other compatible United States routes. Use All Vehicle Scraper when multi-source comparison is intentional.

#### Honest limits and provenance

The normalized Dataset is broader than an Autotrader search card. Fields such as VIN, mileage, dealer name, specifications, images, and dates can be empty. The Actor does not infer them from the keyword or from a different listing. Source links remain the authority for current price, availability, location, seller, and vehicle details.

This Actor is not affiliated with Autotrader. It is not a vehicle inspection, title report, valuation guarantee, dealer lead product, financing service, or private ownership database.

### Quick Start Guide

#### Run one Los Angeles-area test

1. Open [AutoTrader Vehicle Search](https://apify.com/agentx/autotrader-vehicle-search).
2. Keep `country` as `United States` and enter `Toyota Camry`.
3. Optionally enter ZIP `90001`.
4. Set `max_results` to `1`, start the Actor, and confirm `platform` is `Autotrader US` before increasing volume.

Use this identical scenario for the Console and integrations:

```json
{
  "country": "United States",
  "keyword": "Toyota Camry",
  "location": "90001",
  "max_results": 1
}
````

The keyword is used as submitted after trimming surrounding whitespace. A location must resolve to a US ZIP to affect Autotrader. Omit `location` for a nationwide search. `max_results` limits published records but cannot guarantee live inventory.

### Input Parameters

#### Configuration fields

| Parameter | Type | Required | Accepted value and behavior |
| --- | --- | --- | --- |
| `country` | string | Yes | `United States`, the only public market for this Actor. |
| `keyword` | string | Yes | Non-empty make, model, trim, or vehicle search phrase. |
| `location` | string | No | US city or ZIP. A resolved postal code applies a 50-mile source radius. |
| `max_results` | integer | Yes | 1 to 10,000; maximum records returned by the source-locked Autotrader US run. |

Country, keyword, and max results are required; location is optional and has no non-empty default. Source selection is absent because the focused runtime enforces Autotrader US and user input cannot override it.

#### Geographic semantics

Use a five-digit ZIP for predictable behavior. A city can be normalized to a postal code when available. If the location cannot supply a valid ZIP, Autotrader is rejected for that geographic request instead of silently labeling nationwide results as local.

### Output Data Schema

#### Normalized vehicle columns

Each Dataset item follows 33 normalized vehicle fields plus `processor` and `processed_at`, for 35 fields total.

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

This abbreviated example shows the supported contract, not a current listing or a promise that every field appears:

```json
{
  "title": "Used 2023 Toyota Camry SE",
  "price": 23580,
  "currency": "USD",
  "country": "United States",
  "platform": "Autotrader US",
  "source_url": "https://www.autotrader.com/cars-for-sale/vehicle/example",
  "processor": "https://apify.com/username/actor_name",
  "processed_at": "2026-07-21T12:00:00Z"
}
```

Nullable fields are expected when the search result exposes limited detail. Datasets can be exported using formats documented by the current [Dataset items API](https://docs.apify.com/api/v2/dataset-items-get), including JSON, JSONL, CSV, Excel, XML, HTML, and RSS.

### Integration Examples

#### REST API

The intended owner/name identifier is `agentx/autotrader-vehicle-search`. The public Store API returned 404 for that identifier on July 21, 2026. A numeric Actor ID, rating, user count, and historical run metrics are therefore omitted rather than copied from old online data.

After publication, the synchronous endpoint can return the controlled result directly:

```bash
curl -L "https://api.apify.com/v2/actors/agentx~autotrader-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": "United States",
    "keyword": "Toyota Camry",
    "location": "90001",
    "max_results": 1
  }'
```

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

#### MCP

Apify currently documents its hosted Streamable HTTP MCP service:

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

Once published, ask the MCP client to find `agentx/autotrader-vehicle-search`, inspect the input schema, run the one-result scenario, and retrieve the Dataset item. Autotrader US is selected automatically. Authentication is required to run Actors. See the [Apify MCP documentation](https://docs.apify.com/integrations/mcp).

#### Automation tools

Apify schedules, webhooks, Make, n8n, and official client libraries can reuse the same four-field input. Scheduled runs remain source-locked to Autotrader US. Use the current Actor picker after publication and do not paste an unverified numeric ID.

### Pricing & Cost Calculator

AutoTrader Vehicle Search uses pay-per-event pricing. Actor Start is charged when a run begins; 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.00900 | One published Dataset item. |
| Result - BRONZE | $0.00870 | One published Dataset item. |
| Result - SILVER | $0.00840 | One published Dataset item. |
| Result - GOLD | $0.00810 | One published Dataset item. |
| Result - PLATINUM | $0.00810 | One published Dataset item. |
| Result - DIAMOND | $0.00810 | One published Dataset item. |

On the FREE tier, one published record costs $0.01000 + $0.00900 = **$0.01900**. Actor Start can still be charged when no item is published. Each Autotrader US item written to the default Dataset creates one `result` event. Verify Store pricing after publication.

### Use Cases & Applications

#### Search-result monitoring

Run a stable keyword and ZIP scenario on a schedule to collect source-linked inventory snapshots. Compare returned titles and prices while treating each value as a point-in-time listing observation.

#### Regional pricing research

Sample Autotrader results around different ZIP codes and review source pages for price, distance, condition, and seller context. The Actor does not provide an independent fair-value judgment.

#### Internal data workflows

Send Dataset items to a spreadsheet, database, dashboard, search index, or AI-assisted research pipeline. Preserve nullable fields and source provenance; do not let downstream automation manufacture missing vehicle facts.

#### Alternative approaches

Use All Vehicle Scraper when multi-source comparison is intentional. Browse Autotrader manually for a one-off buying decision that needs complete page context. Use an authorized native feed when contractual coverage or every platform-specific field is required.

### FAQ

#### Which inputs are required?

`country`, `keyword`, and `max_results` are required. `location` is optional; no platform selector is exposed.

#### Can I select another United States marketplace?

No. This focused Actor is source-locked to Autotrader US. Use All Vehicle Scraper for another marketplace or multi-source United States research.

#### What does location do?

A valid resolved ZIP is sent to Autotrader with a 50-mile search radius. Omit it for nationwide results.

#### Why is an output record sparse?

Autotrader search results may expose only a title, price, and link. Other normalized fields remain empty rather than being inferred.

#### Does the result limit guarantee inventory?

No. `max_results` is a ceiling controlled by live source availability and qualifying unique links.

#### Can a listing disappear later?

Yes. Availability and price can change after collection. Rerun for current data and treat old output as historical.

#### Can I schedule this Actor?

Yes after publication. Scheduled inputs use the same four fields and remain source-locked to Autotrader US.

#### How is billing counted?

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

### Trust & Data Quality

- **Direct provenance:** publishable records use Autotrader vehicle URLs for review.
- **Schema transparency:** the shared 35-field contract makes nullability visible.
- **Source-lock regression gate:** a record attributed to another platform is treated as a defect.
- **Freshness discipline:** old online metrics are not presented as current Store proof.
- **Conservative claims:** no success rate, coverage guarantee, rating, or performance promise is invented.

For support, provide the run ID, exact input, expected platform, and one public source URL. Do not send API tokens, private data, or dealer credentials.

### Legal & Compliance

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

Independently verify vehicle condition, price, history, seller, and availability before financial, purchase, insurance, or safety decisions. The Actor does not certify listings.

### Related Tools

#### Vehicle research

- [All Vehicle Scraper](https://apify.com/agentx/all-vehicle-scraper) supports deliberate multi-country and multi-source research.
- [Cars Vehicle Search](https://apify.com/agentx/cars-vehicle-search) focuses on Cars.com inventory.
- [Auto Trader UK Vehicle Search](https://apify.com/agentx/auto-trader-uk-vehicle-search) targets the separate UK source and runtime contract.

#### Enrichment and workflow tools

- [Google Maps Store Scraper](https://apify.com/agentx/google-maps-store-scraper) supports separate public dealer or business research.
- [All Shopping Scraper](https://apify.com/agentx/all-shopping-scraper) supports retail comparison workflows.
- [All Jobs Scraper](https://apify.com/agentx/all-jobs-scraper) supports multi-platform hiring data workflows.

These related project directories were verified locally. Recheck every Store link after publication.

### Support & Community

- **Store:** [AutoTrader Vehicle Search](https://apify.com/agentx/autotrader-vehicle-search)
- **API:** [AutoTrader Vehicle Search API](https://apify.com/agentx/autotrader-vehicle-search/api)
- **Official source:** [Autotrader Toyota Camry listings in Los Angeles](https://www.autotrader.com/cars-for-sale/toyota/camry/los-angeles-ca?zip=90001)
- **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 Autotrader surface on **July 21, 2026**. Local Autotrader US-only routing now passes; unresolved Store/API links remain a publication gate.

[**Run one source-controlled Autotrader test**](https://apify.com/agentx/autotrader-vehicle-search) · [**Review the API page**](https://apify.com/agentx/autotrader-vehicle-search/api)

# Actor input Schema

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

United States is the only public market for this focused Actor.

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

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

## `location` (type: `string`):

Optional US city or ZIP code. A resolved ZIP applies a 50-mile Autotrader US search radius.

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

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

## Actor input object example

```json
{
  "country": "United States",
  "keyword": "Toyota Camry",
  "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": "United States",
    "keyword": "Toyota Camry",
    "max_results": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/autotrader-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": "United States",
    "keyword": "Toyota Camry",
    "max_results": 50,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AutoTrader Vehicle Search",
        "description": "Search public Autotrader US vehicle inventory by keyword and optional ZIP radius. Export normalized listing titles, prices, source links, and other available vehicle fields.",
        "version": "1.0",
        "x-build-id": "hWgcRrHwW2TeVeEoD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/agentx~autotrader-vehicle-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-agentx-autotrader-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~autotrader-vehicle-search/runs": {
            "post": {
                "operationId": "runs-sync-agentx-autotrader-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~autotrader-vehicle-search/run-sync": {
            "post": {
                "operationId": "run-sync-agentx-autotrader-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": [
                            "United States"
                        ],
                        "type": "string",
                        "description": "United States 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."
                    },
                    "location": {
                        "title": "📍 Location",
                        "type": "string",
                        "description": "Optional US city or ZIP code. A resolved ZIP applies a 50-mile Autotrader US search radius."
                    },
                    "max_results": {
                        "title": "📊 Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum Autotrader US 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
