# Ricardo.ch Scraper — Listings, Prices & Sellers (`muhammadafzal/ricardo-ch-scraper`) Actor

Scrape public Ricardo.ch listings with prices, auction type, condition, seller ratings, images, shipping, and location. Use for Swiss price monitoring and resale research. Not for login-only or private account data. Returns one flat record per listing. $0.005/listing + $0.005 detailed.

- **URL**: https://apify.com/muhammadafzal/ricardo-ch-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** E-commerce, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 ricardo.ch listings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Ricardo.ch Scraper — Listings, Prices & Sellers

**Ricardo.ch Scraper** collects public marketplace listings from Ricardo.ch and returns clean, schema-stable JSON for price monitoring, resale research, Swiss e-commerce intelligence, and AI agents. Search by free text or provide public search, category, and individual listing URLs. Detailed mode adds condition, seller rating, location, images, shipping, payment methods, attributes, and a cleaned description.

Use Ricardo.ch Scraper when you need reproducible marketplace data rather than manually copying listings. Do not use it for login-only pages, private account data, saved searches, buyer identities, messaging, or checkout automation. The actor does not log in and does not attempt to access private information.

### What data can I extract with Ricardo.ch Scraper?

Each dataset item keeps the same field names across concise and detailed runs. Fields that are unavailable are represented by `null` or an empty array, which makes the output straightforward to consume through the Apify API and MCP Server.

| Field | Description |
|---|---|
| `listingId`, `listingUrl` | Stable Ricardo identifier and canonical public URL |
| `title`, `price`, `currency` | Listing name and displayed CHF price |
| `offerType`, `isAuction`, `endsAt` | Auction or fixed-price metadata |
| `condition`, `availability`, `brand` | Product status and brand |
| `sellerName`, `sellerRatingPercent` | Public seller display data |
| `locationCity`, `postalCode` | Public pickup or seller location |
| `shippingOptions`, `paymentMethods` | Public fulfillment and payment information |
| `imageUrl`, `imageUrls` | Primary image and up to ten detail images |
| `attributes`, `description` | Normalized attributes and cleaned description |
| `scrapedAt`, `_warnings` | Extraction timestamp and non-fatal warnings |

### How much will scraping Ricardo.ch cost?

Ricardo.ch Scraper uses transparent pay-per-event pricing. It exposes a maximum result count before the run starts and stops when the result or user spending cap is reached.

| Event | Price | When it is charged |
|---|---:|---|
| Actor start | $0.00005 per GB | Automatically when the run starts |
| Ricardo.ch listing | $0.005 | After one schema-valid listing is written |
| Detailed enrichment | $0.005 | After detailed listing fields are extracted |

Examples:

- 20 concise listings cost about **$0.10** plus the small start event.
- 20 detailed listings cost about **$0.20** plus the small start event.
- 100 detailed listings cost about **$1.00** plus the small start event.

Underlying platform usage and proxy costs may apply according to the billing option shown by Apify. The run status and `OUTPUT` summary report the actual charged event counts.

### Ricardo.ch Scraper use cases

- Track comparable prices for Swiss resale inventory.
- Monitor auctions and fixed-price offers in a product niche.
- Research product condition, shipping, and seller quality.
- Build a structured Ricardo dataset for analytics or machine learning.
- Feed marketplace listings to Claude, ChatGPT, or another MCP-capable agent.
- Compare Ricardo data with eBay, Google Shopping, AutoScout24, or Craigslist.

Ricardo.ch Scraper is most useful for public marketplace research. It is not an order placement, bidding, messaging, or account-management tool.

### How to use Ricardo.ch Scraper

The smallest input is `{}`. That uses the default `iphone 13` query, detailed format, and a 20-result cap so Apify health checks and first-time users receive a bounded run.

#### Search Ricardo.ch by keyword

```json
{
  "searchQuery": "mechanical keyboard",
  "locale": "de",
  "maxResults": 20,
  "responseFormat": "detailed",
  "minPrice": 50,
  "maxPrice": 300
}
````

Price bounds are applied to extracted result prices. They are not added to Ricardo URLs.

#### Scrape exact public URLs

```json
{
  "startUrls": [
    { "url": "https://www.ricardo.ch/de/s/iphone%2013/" },
    { "url": "https://www.ricardo.ch/de/a/example-listing-1292546868/" }
  ],
  "maxResults": 30,
  "responseFormat": "concise"
}
```

Accepted paths are public German, French, and Italian search (`/s/`), category (`/c/`), and listing (`/a/`) pages. Login, profile, account, and parameterized search/category URLs are rejected with an actionable warning.

#### Concise versus detailed output

Choose `concise` for fast search-card records containing title, price, image, URL, and stable placeholder fields. Choose `detailed` to visit each listing page and enrich it with public structured data. Both modes return the same keys, so downstream code does not need separate schemas.

### Output example

```json
{
  "listingId": "1292546868",
  "title": "Apple iPhone 13 128 GB",
  "listingUrl": "https://www.ricardo.ch/de/a/apple-iphone-13-1292546868/",
  "price": 399,
  "currency": "CHF",
  "offerType": "fixed_price",
  "isAuction": false,
  "condition": "UsedCondition",
  "availability": "InStock",
  "endsAt": "2026-07-20T19:00:00Z",
  "brand": "Apple",
  "locationCity": "Zürich",
  "postalCode": "8001",
  "sellerName": "SwissTechShop",
  "sellerRatingPercent": 99.8,
  "sellerRatingsCount": 1284,
  "categoryPath": ["mobile-phones"],
  "shippingOptions": ["PostPac Priority — CHF 9"],
  "paymentMethods": ["TWINT", "bank_transfer"],
  "imageUrl": "https://img.ricardostatic.ch/images/example/iphone-13",
  "imageUrls": ["https://img.ricardostatic.ch/images/example/iphone-13"],
  "attributes": ["Storage: 128 GB", "Color: Blue"],
  "description": "iPhone 13 in very good condition with original packaging.",
  "responseFormat": "detailed",
  "scrapedAt": "2026-07-13T12:00:00Z",
  "_warnings": []
}
```

The default dataset is available as JSON, CSV, Excel, XML, RSS, and HTML through Apify storage exports. A separate `OUTPUT` key contains request counts, warnings, charged events, spending, proxy mode, and pagination guidance.

### Use Ricardo.ch Scraper through the API

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('muhammadafzal/ricardo-ch-scraper').call({
  searchQuery: 'vintage watch',
  maxResults: 20,
  responseFormat: 'detailed',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('muhammadafzal/ricardo-ch-scraper').call(run_input={
    'searchQuery': 'vintage watch',
    'maxResults': 20,
    'responseFormat': 'detailed',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use Ricardo.ch Scraper through an MCP Server

Ricardo.ch Scraper is exposed through Apify's hosted MCP Server. An agent can discover the actor, construct input from the declared schema, call it, preview results, and page through the dataset without parsing HTML. Use this Streamable HTTP endpoint after publication:

```text
https://mcp.apify.com?tools=muhammadafzal/ricardo-ch-scraper
```

The tool is read-only with respect to Ricardo: it retrieves public listing pages and writes only to the Apify run's own storage.

### Reliability and limitations

Ricardo uses Cloudflare bot protection, so Ricardo.ch Scraper runs a fingerprint-patched Firefox browser through Camoufox and keeps browser, cookies, and network identity consistent within each session. Failed challenge sessions are retired and retried. Heavy images, fonts, and stylesheets are blocked to reduce bandwidth while preserving structured listing data.

Ricardo's robots policy permits base public search pages but disallows parameterized search and category crawling. Therefore, this actor does not automate `?page=` pagination or filter query strings. A search run processes the permitted base result page; pass multiple bare search/category URLs when you need broader compliant coverage. Results can also disappear when a listing ends between search and detail extraction. In that case, the actor preserves available search-card data and adds a warning.

Public marketplace markup can change. The extractor uses semantic links, image alt text, schema.org Product JSON-LD, and Next.js server data rather than relying on one generated CSS class. Nevertheless, schedule maintenance if this actor becomes part of a production monitoring workflow.

### Other dedicated scrapers

- [eBay Scraper](https://apify.com/muhammadafzal/ebay-scraper)
- [Google Shopping Scraper](https://apify.com/muhammadafzal/google-shopping-scraper)
- [AutoScout24 Scraper](https://apify.com/muhammadafzal/autoscout24-scraper)
- [Craigslist Scraper](https://apify.com/muhammadafzal/craigslist-scraper)
- [Google Maps Scraper](https://apify.com/muhammadafzal/google-maps-scraper)
- [Google Maps Restaurant Scraper](https://apify.com/muhammadafzal/google-maps-restaurant-scraper)
- [Domain.com.au Scraper](https://apify.com/muhammadafzal/domain-scraper)
- [Skyscanner Flight Scraper](https://apify.com/muhammadafzal/skyscanner-flight-scraper)
- [Google Scholar Scraper](https://apify.com/muhammadafzal/google-scholar-scraper)
- [Dentist Leads Scraper](https://apify.com/muhammadafzal/worldwide-dentist-scraper)

### Frequently asked questions

#### How many results can I scrape with Ricardo.ch Scraper?

Set `maxResults` from 1 to 200. The actor also honors Apify dataset-item and total-charge caps. Because parameterized pagination is excluded, one bare search page may contain fewer records than the requested cap; multiple permitted Start URLs can expand coverage.

#### Can I integrate Ricardo.ch Scraper with other apps?

Yes. Use datasets, webhooks, schedules, Make, Zapier, n8n, or the Apify API. The flat field names are suitable for databases and spreadsheets.

#### Can I use Ricardo.ch Scraper with the Apify API?

Yes. Call `muhammadafzal/ricardo-ch-scraper`, then read the run's default dataset and `OUTPUT` key. JavaScript and Python examples are included above.

#### Can I use Ricardo.ch Scraper through an MCP Server?

Yes. Add the actor to Apify's hosted MCP Server using the Streamable HTTP URL above. The declared input and dataset schemas help agents select the tool and validate results.

#### Do I need proxies to scrape Ricardo.ch?

Ricardo currently presents Cloudflare challenges to ordinary HTTP clients. Production runs may require Apify residential proxy traffic alongside Camoufox. Proxy use and platform costs are shown in Apify before running.

#### Is it legal to scrape Ricardo.ch data?

This actor retrieves public pages only. Laws, contractual terms, robots policies, database rights, copyright, and privacy obligations vary by jurisdiction and use case. You are responsible for ensuring a lawful basis, following Ricardo's applicable terms, minimizing personal data, respecting rate limits, and not republishing protected content without permission. This actor is unofficial and is not affiliated with or endorsed by Ricardo AG.

#### Your feedback

Report missing fields, changed page structures, or reproducible blocked URLs in the actor's Issues tab. Include a public example URL and run ID, but never post account credentials or private data.

# Actor input Schema

## `searchQuery` (type: `string`):

Use this when you want Ricardo.ch listings matching free text. Enter a phrase such as 'iphone 13' or 'vintage watch'. Defaults to 'iphone 13'. This is not a Ricardo listing URL; use Start URLs for exact pages.

## `startUrls` (type: `array`):

Use this when you already have public Ricardo.ch search, category, or listing URLs. Add entries such as {"url":"https://www.ricardo.ch/de/s/iphone%2013/"}. Defaults to an empty list and then Search query is used. Login, account, and parameterized search URLs are not accepted.

## `locale` (type: `string`):

Use this to choose the Ricardo language for a generated search URL. Accepted values are de, fr, or it; for example 'fr'. Defaults to de. This does not translate listing content or override a locale already present in Start URLs.

## `maxResults` (type: `integer`):

Use this to cap the number of listing records and billable listing events. Enter an integer such as 20. Defaults to 20 and accepts 1–200. This is not a page limit; the actor stops as soon as the record or spending cap is reached.

## `responseFormat` (type: `string`):

Use concise for search-card essentials or detailed for description, seller, shipping, images, and attributes. Accepted values are 'concise' and 'detailed'. Defaults to detailed. This changes enrichment depth, not the stable dataset field names.

## `minPrice` (type: `number`):

Use this to keep listings at or above a CHF price. Enter a number such as 100. Defaults to 0, which disables the lower bound. This is a client-side result filter, not a Ricardo URL parameter.

## `maxPrice` (type: `number`):

Use this to keep listings at or below a CHF price. Enter a number such as 500. Defaults to 0, which disables the upper bound. This is a client-side result filter, not a Ricardo URL parameter.

## Actor input object example

```json
{
  "searchQuery": "iphone 13",
  "startUrls": [
    {
      "url": "https://www.ricardo.ch/de/s/iphone%2013/"
    }
  ],
  "locale": "de",
  "maxResults": 20,
  "responseFormat": "detailed",
  "minPrice": 100,
  "maxPrice": 500
}
```

# Actor output Schema

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

One schema-stable JSON record per public Ricardo.ch listing.

## `summary` (type: `string`):

Counts, billed events, warnings, and pagination guidance for this run.

# 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 = {
    "searchQuery": "iphone 13",
    "startUrls": [
        {
            "url": "https://www.ricardo.ch/de/s/iphone%2013/"
        }
    ],
    "locale": "de",
    "maxResults": 20,
    "responseFormat": "detailed",
    "minPrice": 0,
    "maxPrice": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/ricardo-ch-scraper").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 = {
    "searchQuery": "iphone 13",
    "startUrls": [{ "url": "https://www.ricardo.ch/de/s/iphone%2013/" }],
    "locale": "de",
    "maxResults": 20,
    "responseFormat": "detailed",
    "minPrice": 0,
    "maxPrice": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/ricardo-ch-scraper").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 '{
  "searchQuery": "iphone 13",
  "startUrls": [
    {
      "url": "https://www.ricardo.ch/de/s/iphone%2013/"
    }
  ],
  "locale": "de",
  "maxResults": 20,
  "responseFormat": "detailed",
  "minPrice": 0,
  "maxPrice": 0
}' |
apify call muhammadafzal/ricardo-ch-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=muhammadafzal/ricardo-ch-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ricardo.ch Scraper — Listings, Prices & Sellers",
        "description": "Scrape public Ricardo.ch listings with prices, auction type, condition, seller ratings, images, shipping, and location. Use for Swiss price monitoring and resale research. Not for login-only or private account data. Returns one flat record per listing. $0.005/listing + $0.005 detailed.",
        "version": "1.2",
        "x-build-id": "ndstaqwzVdeumJQej"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/muhammadafzal~ricardo-ch-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-muhammadafzal-ricardo-ch-scraper",
                "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/muhammadafzal~ricardo-ch-scraper/runs": {
            "post": {
                "operationId": "runs-sync-muhammadafzal-ricardo-ch-scraper",
                "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/muhammadafzal~ricardo-ch-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-muhammadafzal-ricardo-ch-scraper",
                "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",
                "properties": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Use this when you want Ricardo.ch listings matching free text. Enter a phrase such as 'iphone 13' or 'vintage watch'. Defaults to 'iphone 13'. This is not a Ricardo listing URL; use Start URLs for exact pages.",
                        "default": "iphone 13"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Use this when you already have public Ricardo.ch search, category, or listing URLs. Add entries such as {\"url\":\"https://www.ricardo.ch/de/s/iphone%2013/\"}. Defaults to an empty list and then Search query is used. Login, account, and parameterized search URLs are not accepted.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "locale": {
                        "title": "Locale",
                        "enum": [
                            "de",
                            "fr",
                            "it"
                        ],
                        "type": "string",
                        "description": "Use this to choose the Ricardo language for a generated search URL. Accepted values are de, fr, or it; for example 'fr'. Defaults to de. This does not translate listing content or override a locale already present in Start URLs.",
                        "default": "de"
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Use this to cap the number of listing records and billable listing events. Enter an integer such as 20. Defaults to 20 and accepts 1–200. This is not a page limit; the actor stops as soon as the record or spending cap is reached.",
                        "default": 20
                    },
                    "responseFormat": {
                        "title": "Response format",
                        "enum": [
                            "concise",
                            "detailed"
                        ],
                        "type": "string",
                        "description": "Use concise for search-card essentials or detailed for description, seller, shipping, images, and attributes. Accepted values are 'concise' and 'detailed'. Defaults to detailed. This changes enrichment depth, not the stable dataset field names.",
                        "default": "detailed"
                    },
                    "minPrice": {
                        "title": "Minimum price (CHF)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Use this to keep listings at or above a CHF price. Enter a number such as 100. Defaults to 0, which disables the lower bound. This is a client-side result filter, not a Ricardo URL parameter.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum price (CHF)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Use this to keep listings at or below a CHF price. Enter a number such as 500. Defaults to 0, which disables the upper bound. This is a client-side result filter, not a Ricardo URL parameter.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
