# Tori Finland Marketplace Scraper (`automation-lab/tori-finland-marketplace-scraper`) Actor

🇫🇮 Extract public Tori.fi secondhand listings with numeric prices, location hierarchy, images, condition, recency, purchase options, and source URLs.

- **URL**: https://apify.com/automation-lab/tori-finland-marketplace-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Tori Finland Marketplace Scraper

Collect public secondhand listings from [Tori.fi](https://www.tori.fi/) search, category, and filtered result pages.

Turn saved Tori searches into structured marketplace data for price tracking, sourcing, inventory alerts, and recommerce research—without signing in or manually copying listing cards.

- 🇫🇮 Built for Finland's Tori marketplace
- 💶 Extracts numeric EUR prices
- 📍 Separates city, district, and region
- 🖼️ Captures listing images and direct URLs
- 🕐 Preserves visible listing recency
- 📦 Detects ToriDiili, buy-now, shipping, and promoted badges
- 🔁 Follows pagination and removes duplicate item IDs

### What does Tori Finland Marketplace Scraper do?

The Actor visits public Tori.fi result pages supplied in `startUrls` and saves one dataset row per visible marketplace listing.

It combines schema.org product data with the rendered listing card. This provides stable product fields plus useful visible signals such as location hierarchy, posted-age text, and purchase badges.

Use the output as JSON, CSV, Excel, XML, RSS, or through the Apify API.

The v1 product intentionally stays on anonymously available listing-result data. It does not claim access to private messages, phone numbers, email addresses, or account-only seller details.

### Who is it for?

#### Recommerce sellers and dealers

Monitor Tori searches for newly listed inventory, compare asking prices, and discover sourcing opportunities by Finnish region.

#### Price-intelligence teams

Build repeat snapshots of product searches and analyze price distributions, condition, brand, and location.

#### Marketplace researchers

Study visible secondhand supply, regional availability, shipping options, and promoted listing patterns.

#### Automation developers

Trigger downstream alerts, spreadsheets, databases, or webhooks whenever a saved search produces new item IDs.

### Why use this Tori.fi scraper?

Manual Tori browsing works for occasional shopping. It becomes slow and inconsistent when you need to monitor several searches every day.

This Actor provides:

- **Repeatability:** run the same filtered URLs on a schedule.
- **Structured prices:** receive numbers instead of formatted price text.
- **Traceability:** every record includes its source page and scrape time.
- **Deduplication:** overlapping inputs do not emit or charge duplicate item IDs.
- **Low overhead:** the HTTP-only implementation does not launch a browser.
- **Fail-closed behavior:** invalid domains and item-detail URLs are rejected.

### What Tori listing data can I extract?

| Field | Type | Meaning |
|---|---|---|
| `itemId` | string | Stable numeric Tori listing identifier |
| `url` | URL | Direct public listing URL |
| `title` | string | Listing headline |
| `description` | string | Short structured description when available |
| `price` | number | Visible asking price |
| `currency` | string | Usually `EUR` |
| `availability` | string | Schema.org availability, such as `InStock` |
| `condition` | string | Schema.org condition, such as `UsedCondition` |
| `brand` | string | Brand exposed on the result page |
| `imageUrl` | URL | Primary listing image |
| `location` | string | Full visible location label |
| `city` | string | Parsed city or municipality |
| `district` | string | Parsed district when present |
| `region` | string | Parsed Finnish region |
| `postedAgo` | string | Tori's visible localized age text |
| `details` | string | Visible size, brand, or card detail text |
| `purchaseAvailable` | boolean | Whether the card displays “Osta heti” |
| `purchaseBadge` | string | Visible ToriDiili badge |
| `shippingBadge` | string | Visible shipping message |
| `promotedBadge` | string | Visible placement/promotion badge |
| `sourceUrl` | URL | Result page that produced the record |
| `pageNumber` | number | Pagination page visited |
| `scrapedAt` | ISO date | Extraction timestamp |

Optional fields are omitted when Tori does not expose them on a card.

### Common Tori marketplace workflows

#### New-inventory monitoring

Paste a Tori search sorted the way you need, run it on a schedule, and compare `itemId` values with your previous dataset.

#### Regional price comparison

Supply separate filtered URLs for Helsinki, Tampere, Turku, or other areas. Group output by `city` or `region` and compare median asking prices.

#### Used-product sourcing

Track searches for bicycles, phones, furniture, tools, collectibles, or other resale categories. Filter downstream on price and posted age.

#### Shipping availability research

Use `purchaseAvailable`, `purchaseBadge`, and `shippingBadge` to segment listings with visible transaction or delivery options.

### How to scrape Tori.fi listings

1. Open a public search, category, or filtered result page on Tori.fi.
2. Copy the complete URL from your browser.
3. Add it to **Tori search or category URLs**.
4. Set **Maximum listings** to the number of unique rows you need.
5. Keep **Maximum pages per URL** as a safety limit.
6. Click **Start**.
7. Open the default dataset to download or integrate the results.

A small first run of 20 listings normally finishes well within two minutes.

### Input

```json
{
  "startUrls": [
    {
      "url": "https://www.tori.fi/recommerce/forsale/search?q=polkupy%C3%B6r%C3%A4"
    }
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 2
}
````

#### Input parameters

| Parameter | Required | Default | Description |
|---|---:|---:|---|
| `startUrls` | yes | Tori search page | Public Tori result URLs |
| `maxItems` | no | `20` | Global unique-listing limit, up to 10,000 |
| `maxPagesPerUrl` | no | `20` | Per-URL pagination limit, up to 100 |

The Actor accepts both request-list objects and raw URL strings through the API.

### Supported Tori URLs and filters

Use public URLs under `https://www.tori.fi/recommerce/forsale/` that show lists of items.

Examples include:

- broad search pages;
- keyword search URLs using `q`;
- category result pages;
- URLs containing Tori's visible price, location, category, or sort filters.

The Actor preserves query parameters exactly and follows Tori's own `next` link.

Individual `/item/` detail URLs are outside the v1 contract and fail with a clear error instead of silently returning misleading data.

### Output example

```json
{
  "itemId": "32826615",
  "url": "https://www.tori.fi/recommerce/forsale/item/32826615",
  "title": "Polkupyörä Nopsa Kombi",
  "description": "Polkupyörä Nopsa Kombi",
  "price": 49,
  "currency": "EUR",
  "availability": "InStock",
  "condition": "UsedCondition",
  "brand": "Helkama",
  "imageUrl": "https://img.tori.net/dynamic/default/item/32826615/example",
  "location": "Hyvinkää, Hakalanmäki-Hakala, Uusimaa",
  "city": "Hyvinkää",
  "district": "Hakalanmäki-Hakala",
  "region": "Uusimaa",
  "postedAgo": "5 t",
  "details": "Helkama",
  "purchaseAvailable": false,
  "sourceUrl": "https://www.tori.fi/recommerce/forsale/search?q=polkupy%C3%B6r%C3%A4",
  "pageNumber": 1,
  "scrapedAt": "2026-07-24T03:52:30.054Z"
}
```

### Pagination and deduplication

Each result URL starts at page one and follows the server-provided next-page link.

Pagination stops when one of these conditions is reached:

- `maxItems` unique listings have been saved;
- `maxPagesPerUrl` pages have been fetched;
- Tori no longer exposes a next link.

The Actor keeps one in-run set of Tori item IDs. If the same listing appears in promoted and organic positions, on overlapping searches, or on repeated input URLs, it is saved and charged only once.

### How much does it cost to scrape Tori listings?

The Actor uses pay-per-event pricing:

- **Run start:** $0.005 per run.
- **Listing extracted:** $0.000039128 per listing on the Bronze plan before tier discounts.

At the Bronze rate, a run producing 100 unique listings costs about **$0.0089**. A 1,000-listing run costs about **$0.0441**.

Apify Free-plan credits can cover small monitoring runs. Your final charge depends on the number of unique listings actually saved and your Apify subscription tier.

Check the live pricing panel for the applicable tier before starting a large run.

### Integrations

#### Google Sheets and Excel

Export the dataset to CSV or Excel for price comparisons, sourcing lists, and manual review.

#### Webhooks and alerting

Send run-finished webhooks to Make, Zapier, n8n, Slack, Discord, or your own endpoint. Compare new item IDs before notifying buyers.

#### Databases and warehouses

Load normalized records into PostgreSQL, BigQuery, Snowflake, or a lakehouse. Use `itemId` as the marketplace identity key and `scrapedAt` for snapshots.

#### Scheduled Apify tasks

Create a task from a saved search input and schedule it hourly or daily. Store previous item IDs downstream to detect newly listed inventory.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tori-finland-marketplace-scraper').call({
  startUrls: [{ url: 'https://www.tori.fi/recommerce/forsale/search?q=iphone' }],
  maxItems: 50,
  maxPagesPerUrl: 3,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/tori-finland-marketplace-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.tori.fi/recommerce/forsale/search?q=sohva'}],
    'maxItems': 50,
    'maxPagesPerUrl': 3,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~tori-finland-marketplace-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://www.tori.fi/recommerce/forsale/search?q=macbook"}],
    "maxItems": 25,
    "maxPagesPerUrl": 2
  }'
```

Fetch results from the run's `defaultDatasetId` after the run succeeds.

### Use with Apify MCP

Connect the Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/tori-finland-marketplace-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/tori-finland-marketplace-scraper"
    }
  }
}
```

Example prompts:

- “Scrape the first 50 listings from this Tori bicycle search and summarize prices by region.”
- “Run my saved Tori furniture URL and return listings with buy-now enabled.”
- “Compare median asking prices across these three Tori search URLs.”

### Tips for reliable monitoring

- Keep the complete filtered URL instead of reconstructing parameters manually.
- Prefer smaller scheduled snapshots over occasional huge runs.
- Sort by newest on Tori when your workflow focuses on inventory alerts.
- Deduplicate historical datasets by `itemId`.
- Treat `postedAgo` as localized display text, not an exact timestamp.
- Keep `maxPagesPerUrl` proportional to the result volume you need.

### Reliability and data quality

The Actor requests server-rendered HTML with a current desktop browser identity.

Core product fields come from schema.org JSON-LD. Card selectors add visible location, recency, detail text, and badges.

Requests retry transient failures twice. Non-200 pages or pages with no listing cards fail the run so monitoring systems do not mistake extraction failure for an empty market.

No proxy is required by the currently verified public route.

### Limitations

- Only public search/category/filter result data is included in v1.
- Seller contact details and account-only information are not extracted.
- `postedAgo` follows Tori's Finnish display format and may be relative.
- Some promoted cards may expose fewer structured fields than organic cards.
- Optional fields are absent when the listing card does not show them.
- Tori can change markup or access behavior over time.

### Is scraping Tori.fi legal?

This Actor extracts publicly visible marketplace listing information.

You are responsible for your use of the data. Review Tori's terms, robots guidance, applicable database rights, copyright rules, privacy law, and the requirements of your jurisdiction.

Do not use the Actor to circumvent authentication, collect private data, spam sellers, discriminate unlawfully, or overload the website.

Use conservative schedules and collect only the fields needed for a legitimate purpose.

### Troubleshooting

#### The run rejects my URL

Confirm the URL uses `tori.fi` and points to a public path under `/recommerce/forsale/`. Individual item pages and unrelated domains are intentionally rejected.

#### The run fails with “No listing cards were found”

Open the exact URL in a normal browser. If it still shows results, retry once and inspect the run log. A persistent error may indicate that Tori changed its result-page markup or temporarily blocked access.

#### I received fewer rows than `maxItems`

The result set may have ended, the page limit may have been reached, or overlapping inputs may have contained duplicate item IDs. Increase `maxPagesPerUrl` only when more pages exist.

### Frequently asked questions

#### Does the Actor require a Tori account?

No. It uses the anonymously visible result-page surface.

#### Does it scrape phone numbers or seller email addresses?

No. Private contact data and account-only seller details are outside the v1 scope.

#### Can I use a filtered Tori URL?

Yes. Paste the complete URL and the Actor preserves its query parameters.

#### Can I monitor several searches in one run?

Yes. Add several URLs to `startUrls`. The global `maxItems` limit and item-ID deduplication apply across all of them.

#### Are prices numbers?

Yes. When a visible price can be parsed, `price` is emitted as a number and `currency` is emitted separately.

#### Can the Actor scrape item detail pages?

Not in v1. This conservative scope prioritizes reliable anonymous search-listing data.

### Related marketplace scrapers

- [Carousell Listings Scraper](https://apify.com/automation-lab/carousell-listings-scraper) — collect secondhand marketplace listings across Carousell markets.
- [Drom.ru Car Marketplace Scraper](https://apify.com/automation-lab/drom-ru-car-marketplace-scraper) — monitor vehicle marketplace listings and prices.

Choose Tori Finland Marketplace Scraper for Finnish general classifieds and the related Actors when your workflow targets those marketplaces.

# Actor input Schema

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

Paste one or more public Tori.fi search, category, or filtered result URLs. Item detail URLs are intentionally not supported.

## `maxItems` (type: `integer`):

Stop after saving this many unique Tori listings across all supplied URLs.

## `maxPagesPerUrl` (type: `integer`):

Safety limit for pagination from each supplied Tori page. The Actor also stops when maximum listings is reached.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tori.fi/recommerce/forsale/search"
    }
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Structured Tori listing rows with identity, price, location, image, condition, recency, and visible purchase badges.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.tori.fi/recommerce/forsale/search"
        }
    ],
    "maxItems": 20,
    "maxPagesPerUrl": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tori-finland-marketplace-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 = {
    "startUrls": [{ "url": "https://www.tori.fi/recommerce/forsale/search" }],
    "maxItems": 20,
    "maxPagesPerUrl": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tori-finland-marketplace-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 '{
  "startUrls": [
    {
      "url": "https://www.tori.fi/recommerce/forsale/search"
    }
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 20
}' |
apify call automation-lab/tori-finland-marketplace-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/tori-finland-marketplace-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tori Finland Marketplace Scraper",
        "description": "🇫🇮 Extract public Tori.fi secondhand listings with numeric prices, location hierarchy, images, condition, recency, purchase options, and source URLs.",
        "version": "0.1",
        "x-build-id": "JKeVZsXwFpHSLUTj0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~tori-finland-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-tori-finland-marketplace-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/automation-lab~tori-finland-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-tori-finland-marketplace-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/automation-lab~tori-finland-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-tori-finland-marketplace-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Tori search or category URLs",
                        "type": "array",
                        "description": "Paste one or more public Tori.fi search, category, or filtered result URLs. Item detail URLs are intentionally not supported.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique Tori listings across all supplied URLs.",
                        "default": 20
                    },
                    "maxPagesPerUrl": {
                        "title": "Maximum pages per URL",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety limit for pagination from each supplied Tori page. The Actor also stops when maximum listings is reached.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
