# Auto Trader UK Vehicle Search (`agentx/auto-trader-uk-vehicle-search`) Actor

Search public Auto Trader UK vehicle inventory by keyword and required UK postcode. Export normalized GBP prices, make, model, year, mileage, seller, location, images, and source URLs through Apify.

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

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

**Auto Trader UK Vehicle Search is a United Kingdom car listings API for keyword and postcode-radius research, publishing GBP prices, vehicle details, seller context, images, and source links in a normalized 35-field Dataset.**

- **Automatic Auto Trader UK source lock:** every focused run is restricted to the named marketplace.
- **Required postcode contract:** every run supplies a UK postcode or a place that resolves to one.
- **Source-native 50-mile scope:** the resolved postcode is applied to the Auto Trader UK search.
- **35 documented fields:** values unavailable for a listing stay empty instead of becoming inferred facts.

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

For the smallest useful test, search `Toyota` near `SW1A 1AA`, set `max_results` to `1`, and budget at most $0.01850 on the FREE tier for one published result plus Actor Start. Open `source_url` before relying on price, mileage, seller, or availability. The intended Store and API destinations returned 404 on July 21, 2026, so publication verification is the remaining release blocker.

### Why Choose This API

#### One UK route with a truthful location requirement

Auto Trader UK Vehicle Search queries public Auto Trader UK inventory around a required UK postcode. Unlike other focused Actors that share a country's runtime route with several sources, the United Kingdom route resolves only to Auto Trader UK. The public form therefore needs no platform field and cannot silently mix another marketplace.

The location field is required because the runtime rejects Auto Trader UK searches without it. When given a valid UK postcode, or a place that normalizes to one, the source request uses a 50-mile radius. This schema alignment prevents a production default from reaching a known runtime rejection.

#### Rich listing context when available

A qualifying result can include title, GBP price, make, model, year, mileage, vehicle location, seller type, primary image, platform attribution, and source URL. Other normalized fields remain available in the Dataset contract but are populated only when supported by source evidence.

The Actor is not affiliated with Auto Trader UK. It does not provide an inspection, title or ownership history, independent valuation, seller certification, financing offer, contact enrichment, or guaranteed inventory. Live listings can change after collection.

### Quick Start Guide

#### Run a London-area Toyota test

1. Open [Auto Trader UK Vehicle Search](https://apify.com/agentx/auto-trader-uk-vehicle-search).
2. Keep `country` set to `United Kingdom` and enter `Toyota`.
3. Keep or replace the required postcode `SW1A 1AA`.
4. Set `max_results` to `1`, start the Actor, and open the returned source URL.

The same input works in the Console and integrations:

```json
{
  "country": "United Kingdom",
  "keyword": "Toyota",
  "location": "SW1A 1AA",
  "max_results": 1
}
````

The keyword is trimmed but not translated, expanded, or replaced. The location must be non-empty and must resolve to a valid UK postcode. `max_results` is a maximum number of publishable records, not a guarantee of live stock.

### Input Parameters

#### Configuration fields

| Parameter | Type | Required | Accepted value and behavior |
| --- | --- | --- | --- |
| `country` | string | Yes | `United Kingdom`, the only public market and the sole Auto Trader UK route. |
| `keyword` | string | Yes | A non-empty vehicle make, model, trim, or search phrase. |
| `location` | string | Yes | UK postcode or place resolving to one; source search uses a 50-mile radius. |
| `max_results` | integer | Yes | 1 to 10,000; maximum Auto Trader UK records returned. |

All four fields are required by the effective public contract. The postcode prefill `SW1A 1AA` makes a first Console run valid, but users should replace it with the geographic area relevant to their research.

#### Why there is no platform field

The runtime locks this Actor to Auto Trader UK before country and postcode checks. Adding a platform selector would not provide a real choice and could imply an unsupported override, so the public contract omits it.

#### Postcode handling

Direct UK postcodes are normalized to uppercase. A place name can be geocoded to a postcode, but a direct postcode is more predictable for repeatable tests. If no valid postcode is available, the run rejects the input instead of labeling unrelated results as local.

### Output Data Schema

#### Normalized vehicle record

Each Dataset item follows 33 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 identity | `year`, `make`, `model`, `trim`, `condition` |
| Specifications | `mileage`, `mileage_unit`, `body_type`, `fuel`, `transmission`, `engine`, `drive_type`, `exterior_color`, `interior_color` |
| Seller and market | `seller`, `seller_type`, `location`, `country`, `platform` |
| Links and dates | `source_url`, `platform_url`, `official_url`, `posted_at`, `updated_at` |
| Processing | `processor`, `processed_at` |

This abbreviated example illustrates the schema without claiming a current listing:

```json
{
  "main_image": "https://example.com/autotrader-uk/toyota-yaris.jpg",
  "title": "Toyota Yaris 1.5 Hybrid Design CVT",
  "price": 18495,
  "currency": "GBP",
  "year": 2022,
  "make": "Toyota",
  "model": "Yaris",
  "mileage": 24000,
  "mileage_unit": "mi",
  "location": "London",
  "seller": "Trade",
  "country": "United Kingdom",
  "platform": "Auto Trader UK",
  "source_url": "https://www.autotrader.co.uk/car-details/example",
  "processor": "https://apify.com/username/actor_name",
  "processed_at": "2026-07-21T12:00:00Z"
}
```

Search results may omit specifications, identifiers, or dates. Empty values are valid and should remain nullable downstream. Current export formats are documented in the [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/auto-trader-uk-vehicle-search`. The public Store API did not return a current record for that identifier on July 21, 2026. This README therefore omits a numeric Actor ID, rating, user count, and old online run data.

After publication, use the synchronous endpoint with the required postcode:

```bash
curl -L "https://api.apify.com/v2/actors/agentx~auto-trader-uk-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 Kingdom",
    "keyword": "Toyota",
    "location": "SW1A 1AA",
    "max_results": 1
  }'
```

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

#### MCP

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 locate `agentx/auto-trader-uk-vehicle-search`, inspect its schema, run the one-result Toyota and `SW1A 1AA` scenario, and return the Dataset item. Authentication is required to run Actors. Review the [Apify MCP guide](https://docs.apify.com/integrations/mcp).

#### Scheduled and workflow runs

Apify schedules, webhooks, Make, n8n, and client libraries can reuse the same four-field input. Each saved input must contain a valid postcode. Use the current Actor picker after publication rather than an unverified numeric ID.

### Pricing & Cost Calculator

Auto Trader UK Vehicle Search uses pay-per-event pricing. Actor Start is charged at run start; one `result` event is charged for each item written to the default Dataset.

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

On the FREE tier, one published listing costs $0.01000 + $0.00850 = **$0.01850**. A run that publishes no record can still incur Actor Start. Actual totals depend on the applicable tier and number of Dataset items. Confirm the live pricing panel after publication.

### Use Cases & Applications

#### Local inventory research

Collect source-linked Toyota or other make/model results around a fixed postcode. Repeat the same input to build point-in-time inventory snapshots without changing geographic semantics.

#### Asking-price and mileage comparison

Compare GBP price, year, mileage, model, and location when present. Open source pages for any outlier and do not treat an asking price as a guaranteed sale price or independent valuation.

#### Seller and listing review

Create internal queues using seller type, vehicle location, image, and source URL when available. A public seller field does not grant permission for unsolicited contact or profiling.

#### Data and AI workflows

Load the normalized Dataset into spreadsheets, databases, dashboards, indexes, or internal analysis tools. Preserve nullable fields and provenance. Automated conclusions should not replace an inspection or direct source review.

#### Alternatives

Use All Vehicle Scraper when multi-country comparison is intentional. Browse Auto Trader UK manually for a single purchase decision needing full native context. Use an authorized data feed when contractual completeness or all platform-specific fields are required.

### FAQ

#### Which inputs are required?

All four public fields are required: `country`, `keyword`, `location`, and `max_results`.

#### Why is a postcode required?

The Auto Trader UK route requires a location and a resolved postcode. The source search uses a 50-mile radius.

#### Can I omit platforms?

There is no platform field. The focused Actor is source-locked to Auto Trader UK and user input cannot broaden the route.

#### Can I use a city name?

Yes when it resolves to a UK postcode, but a direct postcode produces a more repeatable input.

#### Why are some fields empty?

Individual listings do not expose all 35 normalized fields. Missing values are not invented.

#### Does `max_results` guarantee the count?

No. It is a ceiling governed by live inventory, source responses, unique listings, and publishable records.

#### Can a listing become stale?

Yes. Listings and prices can change after collection. Rerun for current data and treat prior output as historical.

#### How is billing counted?

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

### Trust & Data Quality

- **Single-source route:** United Kingdom maps only to Auto Trader UK.
- **Valid default scenario:** the schema now requires location and prefills a valid UK postcode.
- **Source traceability:** direct vehicle links support manual review.
- **Transparent nullability:** unsupported fields stay empty.
- **Current-proof discipline:** legacy online data is not used as current Store evidence.

For a reproducible issue, provide the run ID, exact four-field input, expected behavior, and one public source URL. Never include API tokens or private data.

### Legal & Compliance

Auto Trader UK Vehicle Search is intended for lawful analysis of publicly accessible listing information. Users are responsible for source terms, applicable laws, 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 price, condition, history, seller, location, and availability before purchase, financing, insurance, valuation, or safety decisions. This Actor does not certify vehicles or sellers.

### Related Tools

#### Vehicle research

- [All Vehicle Scraper](https://apify.com/agentx/all-vehicle-scraper) supports intentional multi-country and multi-source research.
- [AutoTrader Vehicle Search](https://apify.com/agentx/autotrader-vehicle-search) targets the separate United States Autotrader source.
- [Cars Vehicle Search](https://apify.com/agentx/cars-vehicle-search) focuses on Cars.com inventory.

#### Enrichment and workflow tools

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

The related project directories were verified locally. Their Store links must be rechecked after publication.

### Support & Community

- **Store:** [Auto Trader UK Vehicle Search](https://apify.com/agentx/auto-trader-uk-vehicle-search)
- **API:** [Auto Trader UK Vehicle Search API](https://apify.com/agentx/auto-trader-uk-vehicle-search/api)
- **Official source:** [Auto Trader UK Toyota listings in London](https://www.autotrader.co.uk/cars/uk/london/toyota)
- **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 Auto Trader UK surface on **July 21, 2026**. Local Auto Trader UK-only routing passes; unresolved Store/API links remain the release blocker.

[**Run one postcode-valid UK test**](https://apify.com/agentx/auto-trader-uk-vehicle-search) · [**Review the API page**](https://apify.com/agentx/auto-trader-uk-vehicle-search/api)

# Actor input Schema

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

United Kingdom is the only public market and routes only to Auto Trader UK.

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

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

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

Required UK postcode or place that resolves to a UK postcode. The source search uses a 50-mile radius.

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

Maximum Auto Trader UK records returned. This is a ceiling, not guaranteed inventory.

## Actor input object example

```json
{
  "country": "United Kingdom",
  "keyword": "Toyota",
  "location": "SW1A 1AA",
  "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 Kingdom",
    "keyword": "Toyota",
    "location": "SW1A 1AA",
    "max_results": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/auto-trader-uk-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 Kingdom",
    "keyword": "Toyota",
    "location": "SW1A 1AA",
    "max_results": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("agentx/auto-trader-uk-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 Kingdom",
  "keyword": "Toyota",
  "location": "SW1A 1AA",
  "max_results": 50
}' |
apify call agentx/auto-trader-uk-vehicle-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Auto Trader UK Vehicle Search",
        "description": "Search public Auto Trader UK vehicle inventory by keyword and required UK postcode. Export normalized GBP prices, make, model, year, mileage, seller, location, images, and source URLs through Apify.",
        "version": "1.0",
        "x-build-id": "RgTcEZm7v0pXhZehS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/agentx~auto-trader-uk-vehicle-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-agentx-auto-trader-uk-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~auto-trader-uk-vehicle-search/runs": {
            "post": {
                "operationId": "runs-sync-agentx-auto-trader-uk-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~auto-trader-uk-vehicle-search/run-sync": {
            "post": {
                "operationId": "run-sync-agentx-auto-trader-uk-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",
                    "location",
                    "max_results"
                ],
                "properties": {
                    "country": {
                        "title": "🌍 Country",
                        "enum": [
                            "United Kingdom"
                        ],
                        "type": "string",
                        "description": "United Kingdom is the only public market and routes only to Auto Trader UK."
                    },
                    "keyword": {
                        "title": "🔍 Keyword",
                        "type": "string",
                        "description": "Required vehicle make, model, or search phrase sent without translation or replacement."
                    },
                    "location": {
                        "title": "📍 Location",
                        "type": "string",
                        "description": "Required UK postcode or place that resolves to a UK postcode. The source search uses a 50-mile radius."
                    },
                    "max_results": {
                        "title": "📊 Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum Auto Trader UK 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
