# Webmotors Car Listing (`truefetch/webmotors-car-listing`) Actor

Search public Webmotors vehicle inventory across Brazil by keyword. Export normalized titles, prices, images, listing IDs, source URLs, and other available vehicle fields through Apify.

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

## Pricing

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

> **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.

**Webmotors Car Listing is a Brazil vehicle inventory API that searches public Webmotors results by keyword and publishes source-linked records in one normalized 35-field Dataset.**

- **Automatic Webmotors source lock:** every focused run is restricted to the named marketplace.
- **Three-field public input:** country, keyword, and a result ceiling are the complete user-facing contract.
- **Official inventory pages:** records are accepted from Webmotors cards, structured data, or verified `/comprar/` links.
- **35 documented output fields:** values absent from a source result remain empty instead of becoming inferred facts.

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

For the smallest test, use `Toyota`, set `max_results` to `1`, and budget at most $0.02300 on the FREE tier for one result plus Actor Start. Verify `source_url` before using a price or vehicle fact. The intended Store and API pages were not live during the July 21, 2026 audit, so publication remains a release prerequisite.

### What does Webmotors Car Listing do?

Webmotors Car Listing converts a vehicle keyword into a public Webmotors inventory path, requests the official page, and publishes qualifying vehicle records. It recognizes vehicle cards, structured JSON-LD entries, and Webmotors detail links containing `/comprar/`. A record can include a source title, numeric or formatted price, BRL currency, image, Webmotors listing ID, Brazil attribution, platform name, and direct source URL when those values appear in the search response.

The Actor intentionally uses a focused public input. `Brazil` is the only country, and the runtime has only one compatible source for that country: Webmotors. There is no platform field to forget and no location control that the current adapter cannot natively honor.

The Actor is not affiliated with Webmotors. It collects publicly accessible search-result information; it is not an inspection, valuation guarantee, ownership-history report, financing offer, or private dealer database. Listings, prices, and availability can change after collection, so important decisions require source-page verification.

### How do I run Webmotors Car Listing?

1. Open the [Webmotors Car Listing input page](https://apify.com/truefetch/webmotors-car-listing?fpr=aiagentapi).
2. Keep `country` set to `Brazil` and enter a make or model phrase such as `Toyota`.
3. Set `max_results` to `1` for the first run and click **Start**.
4. Confirm that `platform` is Webmotors and open `source_url` before increasing the ceiling.

Use this same scenario in the Console, API, or an Apify integration:

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

The keyword is trimmed and converted into the source inventory path without adding a location. `max_results` is a maximum number of publishable records, not guaranteed inventory. A blocked, changed, or empty source page can produce fewer results.

### What data does Webmotors Car Listing return?

Every published item uses the same 35-field Dataset contract. Search pages often expose only a subset; unobserved values remain empty.

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

This abbreviated example illustrates the normalized contract rather than a guaranteed live listing:

```json
{
  "main_image": "https://example.com/webmotors/toyota-corolla.jpg",
  "title": "Toyota Corolla 2.0 Flex",
  "price": 119990,
  "currency": "BRL",
  "year": 2021,
  "make": "Toyota",
  "model": "Corolla",
  "mileage": 56635,
  "mileage_unit": "km",
  "country": "Brazil",
  "platform": "Webmotors",
  "source_url": "https://www.webmotors.com.br/comprar/example/123456",
  "listing_id": "123456",
  "processor": "https://apify.com/username/actor_name",
  "processed_at": "2026-07-21T12:00:00Z"
}
```

Apify Datasets can be retrieved in 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 | `Brazil`, the only public country and the route to Webmotors. |
| `keyword` | string | Yes | A non-empty vehicle make, model, or phrase sent without translation or replacement. |
| `max_results` | integer | Yes | From 1 to 10,000; the maximum number of Webmotors records published. |

All three fields are required by the current runtime. The schema supplies convenient prefill values, but the Actor respects the submitted keyword and result ceiling.

There is no public `platforms` field because the runtime locks this Actor to Webmotors before routing. There is no public `location` field because the adapter builds a countrywide inventory URL and does not apply a user location to the native request. Removing controls that have no useful effect makes the Store form safer and easier to understand.

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

This Actor covers public Webmotors vehicle inventory in Brazil. The audited adapter begins from a URL such as the official [Toyota inventory page](https://www.webmotors.com.br/carros/estoque/toyota), validates that the response contains Webmotors purchase links, and parses unique detail destinations.

The route does not claim every vehicle, category, city, seller, or Webmotors feature. Availability depends on the live keyword page, source markup, network response, and qualifying records. Fields visible only after interaction or on a separate detail view may not be present in a search-result item.

For cross-country or multi-marketplace research, use [Global Car Listing](https://apify.com/truefetch/global-car-listing?fpr=aiagentapi). Do not pass an old online result as proof of current Webmotors inventory; rerun the Actor and inspect current links.

### Why use Webmotors Car Listing?

| Verified capability | Practical benefit |
| --- | --- |
| Single Brazil route | The focused Actor cannot silently mix another marketplace into a normal run. |
| Native keyword inventory path | Keep source search semantics without inventing extra filters. |
| Normalized 35-field Dataset | Store repeated exports in stable columns even when values are optional. |
| Direct `/comprar/` links | Review the original Webmotors record before relying on a vehicle or price. |
| Per-result billing | Associate most cost with items actually written to the Dataset. |

The key trade-off is search-page depth. The Actor publishes what it can verify from the inventory response; it does not promise every detail available elsewhere on Webmotors.

### Who is Webmotors Car Listing for?

Webmotors Car Listing is designed for developers, Brazil automotive analysts, dealer researchers, pricing teams, inventory monitors, and data operations specialists. Useful workflows include make/model inventory samples, asking-price comparisons, listing discovery, repeat keyword checks, source-link review queues, spreadsheet exports, and scheduled internal market snapshots.

It is not a substitute for a licensed vehicle inspection, official registration record, financial advice, dealer consent workflow, or guaranteed comprehensive feed. Teams needing every source-specific detail should evaluate a dedicated integration and its legal or contractual requirements.

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

The intended owner/name identifier is `truefetch/webmotors-car-listing`. The public Store API returned no current record for that identifier on July 21, 2026, so this README does not invent a numeric Actor ID or live usage statistics.

After publication, the synchronous endpoint can return Dataset items directly:

```bash
curl -L "https://api.apify.com/v2/actors/truefetch~webmotors-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": "Brazil",
    "keyword": "Toyota",
    "max_results": 1
  }'
```

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

Apify documents a hosted Streamable HTTP MCP server:

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

After publication, ask the MCP client to locate `truefetch/webmotors-car-listing`, inspect the input schema, run the one-result Toyota scenario, and return the Dataset item. Authentication is required to run Actors. Review the [Apify MCP guide](https://docs.apify.com/integrations/mcp).

### How much does Webmotors Car Listing cost?

The Actor uses pay-per-event pricing. Actor Start is charged once at run start; a `result` event is charged for every item written to the default Dataset.

| Billed event and tier | Price per event | Billing unit |
| --- | ---: | --- |
| Actor Start | $0.01000 | One Actor run start. |
| Result - FREE | $0.01300 | One published Dataset item. |
| Result - BRONZE | $0.01257 | One published Dataset item. |
| Result - SILVER | $0.01213 | One published Dataset item. |
| Result - GOLD | $0.01170 | One published Dataset item. |
| Result - PLATINUM | $0.01170 | One published Dataset item. |
| Result - DIAMOND | $0.01170 | One published Dataset item. |

On the FREE tier, one result costs $0.01000 + $0.01300 = **$0.02300**. A run with no published records can still incur Actor Start. Actual totals depend on published items and the applicable tier. Confirm pricing on the live Store page after publication.

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

| Option | Best fit | Trade-off |
| --- | --- | --- |
| Webmotors Car Listing | Repeatable Brazil Webmotors discovery with normalized output. | Search pages may expose fewer fields than detail pages. |
| Global Car Listing | Multi-country or multi-source automotive research. | Its broader form and routing are unnecessary for a Webmotors-only task. |
| Manual Webmotors browsing | One-off inspection with full page context. | Difficult to schedule, export, and compare at scale. |
| Dedicated native integration | Teams requiring all Webmotors-specific fields or workflows. | More implementation, monitoring, and normalization work. |

Choose the focused Actor when source-linked search results and a stable cross-run schema are more important than capturing every native field.

### What are the limits and troubleshooting steps?

| Symptom or limit | Explanation and next step |
| --- | --- |
| The run returns fewer records than requested | `max_results` is a ceiling; live inventory and parseable detail links control output. |
| Optional fields are empty | Search cards and structured data do not expose every shared schema field. Open `source_url`. |
| The input rejects another country | Brazil is the only public market for this focused Actor. |
| No location field appears | The adapter performs a countrywide keyword inventory request and has no native user-location parameter. |
| A source page is blocked or changed | Webmotors can change firewall behavior or markup; retry later and provide a public failing URL to support. |
| An older record no longer exists | Listings are mutable; treat old output as historical and rerun for current inventory. |

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

### Frequently asked questions

#### Which inputs are required?

`country`, `keyword`, and `max_results` are all required.

#### Is Webmotors selected automatically?

Brazil has only one compatible route in the audited runtime, so the run resolves to Webmotors without a platform field.

#### Can I filter by city?

Not with the current public schema. The adapter builds a countrywide inventory URL from the keyword.

#### Does `max_results` guarantee inventory?

No. It limits published items but cannot create or preserve source listings.

#### Why are some fields empty?

The normalized schema is broader than the values exposed by an individual search result.

#### Can I schedule runs?

Yes. Keep the exact country and keyword inputs with the schedule and compare current source links.

#### How is billing counted?

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

#### Are old Store metrics current proof?

No. The user identified online data as old, and this audit relies on local runtime evidence and current official source behavior instead.

### Related TrueFetch Actors

- [Global Car Listing](https://apify.com/truefetch/global-car-listing?fpr=aiagentapi) supports multi-country and multi-source vehicle research.
- [28car Car Listing](https://apify.com/truefetch/28car-car-listing?fpr=aiagentapi) focuses on Hong Kong vehicle classifieds.
- [Mobile DE Car Listing](https://apify.com/truefetch/mobile-de-car-listing?fpr=aiagentapi) targets German mobile.de inventory.

These related directories were verified locally. Their public links must be checked again after each Actor is published.

### Support and last updated

- **Store:** [Webmotors Car Listing](https://apify.com/truefetch/webmotors-car-listing?fpr=aiagentapi)
- **API:** [Webmotors Car Listing API](https://apify.com/truefetch/webmotors-car-listing/api?fpr=aiagentapi)
- **Source:** [Webmotors Toyota inventory](https://www.webmotors.com.br/carros/estoque/toyota)
- **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 Webmotors inventory surface on **July 21, 2026**. Local Webmotors-only routing passes; unresolved prepublication Store/API and related-Actor links remain release blockers.

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

# Actor input Schema

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

Brazil is the only public market for this focused Actor and routes to Webmotors.

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

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

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

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

## Actor input object example

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

# Actor output Schema

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

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

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "country": "Brazil",
    "keyword": "Toyota",
    "max_results": 50
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Webmotors Car Listing",
        "description": "Search public Webmotors vehicle inventory across Brazil by keyword. Export normalized titles, prices, images, listing IDs, source URLs, and other available vehicle fields through Apify.",
        "version": "1.0",
        "x-build-id": "i9GjwsgbijiewIspT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/truefetch~webmotors-car-listing/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-truefetch-webmotors-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~webmotors-car-listing/runs": {
            "post": {
                "operationId": "runs-sync-truefetch-webmotors-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~webmotors-car-listing/run-sync": {
            "post": {
                "operationId": "run-sync-truefetch-webmotors-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": [
                            "Brazil"
                        ],
                        "type": "string",
                        "description": "Brazil is the only public market for this focused Actor and routes to Webmotors."
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Required vehicle make, model, or search phrase sent without translation or replacement."
                    },
                    "max_results": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum Webmotors 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
