# Mobile DE Car Listing (`truefetch/mobile-de-car-listing`) Actor

Search public mobile.de vehicle inventory across Germany by keyword and optional postal location. Export normalized prices, years, mileage, listing links, and other available fields.

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

## Pricing

from $5.48 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

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

**Mobile DE Car Listing is a source-locked Germany vehicle inventory API that searches mobile.de by keyword and optional postal area and publishes a normalized 35-field Dataset.**

- **Germany-only public country:** the focused input cannot route to unrelated international vehicle markets.
- **Automatic mobile.de source lock:** every focused run is restricted to the named marketplace.
- **Native postal-radius support:** a resolved German postcode applies mobile.de's 50 km search radius.
- **35 documented output fields:** unsupported source values remain empty instead of becoming inferred vehicle facts.

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

For the smallest controlled test, set `max_results` to `1` and budget at most $0.02250 on the FREE tier for one result plus Actor Start. Verify `platform` and `source_url` before scaling. The intended Store and API pages were not live during the July 21, 2026 audit, so publication remains a release prerequisite.

### What does Mobile DE Car Listing do?

Mobile DE Car Listing sends a vehicle keyword to mobile.de's public car search and normalizes qualifying result links. The adapter recognizes official `/fahrzeuge/details.html` destinations, listing-card text, structured page data, price strings, first-registration years, and kilometre values. A published item can therefore contain a title, price, currency, year, mileage, Germany attribution, platform name, and direct source URL when those values are exposed by the live results page.

An optional location can be supplied as a German city or five-digit postcode. When location normalization produces a postcode, the adapter sends it to mobile.de with a 50 km radius. Without location, it performs a Germany-wide keyword search.

The runtime now locks this focused Actor to mobile.de before applying country, location, and query-capability checks. Its public schema contains no platform selector, and input cannot broaden a run to AutoScout24. Global Car Listing remains available for intentional multi-source Germany research.

The Actor is not affiliated with mobile.de. It is not an inspection, valuation guarantee, ownership-history service, financing offer, or private dealer database. Source records can change after collection.

### How do I run Mobile DE Car Listing?

1. Open the [Mobile DE Car Listing input page](https://apify.com/truefetch/mobile-de-car-listing?fpr=aiagentapi).
2. Keep `country` set to `Germany` and enter a vehicle phrase such as `Toyota`.
3. Optionally enter `10115` or another German location for a resolved 50 km postal radius.
4. Set `max_results` to `1`, run the Actor, and confirm `platform` is `mobile.de` before increasing volume.

This source-locked example applies a Berlin postcode:

```json
{
  "country": "Germany",
  "keyword": "Toyota",
  "location": "10115",
  "max_results": 1
}
````

The keyword is trimmed but not translated or expanded. `max_results` is the mobile.de run maximum, not guaranteed inventory. A source page can contain fewer unique, publishable detail links.

### What data does Mobile DE Car Listing return?

Every item follows a 35-field shared Dataset schema. mobile.de search results usually expose a subset; missing values remain empty.

| Field group | Public fields | Meaning |
| --- | --- | --- |
| Listing identity | `title`, `listing_id`, `vin`, `description` | Source title, text, and identifiers when available. |
| Images | `main_image`, `images` | Primary image and image collection when published. |
| Price | `price`, `currency`, `price_text` | Parsed amount, EUR or source currency, and formatted price text. |
| Vehicle identity | `year`, `make`, `model`, `trim`, `condition` | First-registration year and source vehicle identity values. |
| Specifications | `mileage`, `mileage_unit`, `body_type`, `fuel`, `transmission`, `engine`, `drive_type`, `exterior_color`, `interior_color` | Kilometres and optional source-published specifications. |
| Seller and market | `seller`, `seller_type`, `location`, `country`, `platform` | Dealer or seller context, Germany, and route attribution. |
| Links and dates | `source_url`, `platform_url`, `official_url`, `posted_at`, `updated_at` | Listing traceability and source dates when exposed. |
| Processing | `processor`, `processed_at` | Actor attribution and UTC processing time. |

This abbreviated record illustrates the contract without claiming a current listing:

```json
{
  "title": "Toyota Corolla 2.0 Hybrid Touring Sports",
  "price": 23845,
  "currency": "EUR",
  "year": 2022,
  "make": "Toyota",
  "model": "Corolla",
  "mileage": 80895,
  "mileage_unit": "km",
  "location": "10115 Berlin",
  "country": "Germany",
  "platform": "mobile.de",
  "source_url": "https://suchen.mobile.de/fahrzeuge/details.html?id=example",
  "processor": "https://apify.com/username/actor_name",
  "processed_at": "2026-07-21T12:00:00Z"
}
```

Retrieve Datasets using 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 | `Germany`, the only public country for this release. |
| `keyword` | string | Yes | A non-empty vehicle make, model, or phrase sent without translation. |
| `location` | string | No | German city or five-digit postcode; mobile.de uses a resolved postcode with a 50 km radius. |
| `max_results` | integer | Yes | From 1 to 10,000, applied to the source-locked mobile.de run. |

The runtime requires country, keyword, and max results; location remains optional and has no non-empty default. Source selection is absent because this focused Actor enforces mobile.de and user input cannot override it.

If a supplied location cannot resolve to a postal code, mobile.de is rejected for that location rather than pretending to apply a geographic filter. For a countrywide search, omit `location` entirely.

### What platforms and markets does Mobile DE Car Listing cover?

The public market is Germany. The named source is [mobile.de Toyota inventory](https://suchen.mobile.de/auto/toyota.html?lang=en), where public result pages can show new and used vehicles, asking prices, first registration, mileage, fuel, dealer context, and detail links. The Actor publishes only the values it observes and normalizes.

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

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

### Why use Mobile DE Car Listing?

| Verified capability | Practical benefit |
| --- | --- |
| Automatic mobile.de source lock | Keep platform attribution and detail links on the intended source without a user filter. |
| Germany-focused public schema | Prevent accidental routing to unrelated international marketplaces. |
| Optional postcode radius | Narrow mobile.de results using a source-native geographic request. |
| Normalized 35-field Dataset | Load repeated runs into stable columns even when fields are absent. |
| Direct source URLs | Verify the listing page before relying on price, mileage, or seller details. |

The main trade-off is source specialization: the Actor is mobile.de-only and returns a normalized subset rather than every native marketplace field.

### Who is Mobile DE Car Listing for?

Mobile DE Car Listing is intended for developers, German automotive analysts, dealer researchers, pricing teams, inventory monitors, and data operations specialists. Common uses include make/model inventory samples, regional asking-price comparisons, postcode-based listing discovery, scheduled keyword checks, source-link review queues, and normalized exports for internal dashboards.

It does not replace an inspection, registration record, independent valuation, seller consent workflow, or source-specific feed guaranteeing every native field. Use Global Car Listing when multiple Germany sources are required.

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

The intended owner/name identifier is `truefetch/mobile-de-car-listing`. The public Store API did not return a current record for that identifier on July 21, 2026, so no numeric Actor ID or legacy Store statistics are presented as current proof.

After publication, use the synchronous endpoint with the complete public input:

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

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

Apify 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/mobile-de-car-listing`, inspect its schema, run the one-result Toyota scenario, and retrieve the item. mobile.de is selected automatically. Authentication is required to run Actors. See the [Apify MCP guide](https://docs.apify.com/integrations/mcp).

### How much does Mobile DE Car Listing cost?

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

| Billed event and tier | Price per event | Billing unit |
| --- | ---: | --- |
| Actor Start | $0.01000 | One Actor run start. |
| Result - FREE | $0.01250 | One published Dataset item. |
| Result - BRONZE | $0.01208 | One published Dataset item. |
| Result - SILVER | $0.01167 | One published Dataset item. |
| Result - GOLD | $0.01125 | One published Dataset item. |
| Result - PLATINUM | $0.01125 | One published Dataset item. |
| Result - DIAMOND | $0.01125 | One published Dataset item. |

On the FREE tier, one published mobile.de result costs $0.01000 + $0.01250 = **$0.02250**. A run with no records can still incur Actor Start. Each mobile.de record written to the default Dataset creates one `result` event. Confirm live pricing after publication.

### How does Mobile DE Car Listing compare with alternatives?

| Option | Best fit | Trade-off |
| --- | --- | --- |
| Mobile DE Car Listing | Repeatable source-locked mobile.de research with normalized output and optional postcode radius. | Native fields absent from results remain empty. |
| Global Car Listing | Multi-country or multi-source automotive analysis. | Its broader scope is unnecessary for a mobile.de-only job. |
| Manual mobile.de browsing | One-off review with full source-page context. | Difficult to schedule, export, or compare repeatedly. |
| Dedicated native integration | Teams requiring every mobile.de-specific field. | More implementation, monitoring, and normalization work. |

Choose this Actor when mobile.de-only normalized search results match the workflow. Use Global Car Listing for multi-source comparison.

### What are the limits and troubleshooting steps?

| Symptom or limit | Explanation and next step |
| --- | --- |
| A result identifies AutoScout24 or another source | Treat it as a source-lock regression; stop scaling and send the run ID plus source URL to support. |
| A location is rejected | It did not resolve to a German postcode required by the mobile.de postal filter. Try a five-digit postcode. |
| Fewer records arrive than requested | `max_results` is a ceiling; live inventory and unique detail links determine output. |
| Optional fields are empty | A search result does not expose every normalized vehicle field. Verify `source_url`. |
| A listing link no longer opens | Listings can be changed or removed after collection; rerun for current inventory. |
| Later pages stop early | A follow-up source request returned no usable page; retain completed records and retry later. |

For support, send the run ID, exact input, expected platform, and one public source URL. Never send API tokens or private data.

### Frequently asked questions

#### Which inputs are required?

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

#### Can I select AutoScout24 instead?

No. This focused Actor is locked to mobile.de. Use Global Car Listing for AutoScout24 or multi-source Germany searches.

#### What location should I enter?

Use a German city or five-digit postcode. The resolved postcode is sent with a 50 km radius.

#### Can I run a countrywide search?

Yes. Omit `location`; the Actor remains locked to mobile.de.

#### Why are some fields empty?

The normalized schema is broader than the subset exposed on each mobile.de result card.

#### Can I schedule the Actor?

Yes. Scheduled inputs use the same four-field contract, and the Actor remains locked to mobile.de.

#### How is billing counted?

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

#### Are old online metrics current proof?

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

### Related TrueFetch Actors

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

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

### Support and last updated

- **Store:** [Mobile DE Car Listing](https://apify.com/truefetch/mobile-de-car-listing?fpr=aiagentapi)
- **API:** [Mobile DE Car Listing API](https://apify.com/truefetch/mobile-de-car-listing/api?fpr=aiagentapi)
- **Source:** [mobile.de Toyota inventory](https://suchen.mobile.de/auto/toyota.html?lang=en)
- **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 mobile.de surface on **July 21, 2026**. Local mobile.de-only routing now passes; unresolved Store/API links remain a publication gate.

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

# Actor input Schema

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

Germany 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 German city or 5-digit postal code. A resolved postal code applies a 50 km mobile.de search radius.

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

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

## Actor input object example

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mobile DE Car Listing",
        "description": "Search public mobile.de vehicle inventory across Germany by keyword and optional postal location. Export normalized prices, years, mileage, listing links, and other available fields.",
        "version": "1.0",
        "x-build-id": "OJvm4VZQKRJgiAHHz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/truefetch~mobile-de-car-listing/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-truefetch-mobile-de-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~mobile-de-car-listing/runs": {
            "post": {
                "operationId": "runs-sync-truefetch-mobile-de-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~mobile-de-car-listing/run-sync": {
            "post": {
                "operationId": "run-sync-truefetch-mobile-de-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": [
                            "Germany"
                        ],
                        "type": "string",
                        "description": "Germany 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 German city or 5-digit postal code. A resolved postal code applies a 50 km mobile.de search radius."
                    },
                    "max_results": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum normalized mobile.de 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
