# Gumtree Property Scraper (`vivid-softwares/gumtree-scraper`) Actor

UK Gumtree property scraper - property to rent, rooms & flatshare. Paste any filtered gumtree.com search URL; structured titles, prices, location, description & images. Fast HTTP, Apify Proxy, cross-run dedupe, optional pw-to-pm rent. Pay per result - R2R, lettings & comparables. JSON/CSV export.

- **URL**: https://apify.com/vivid-softwares/gumtree-scraper.md
- **Developed by:** [VividSoftwares](https://apify.com/vivid-softwares) (community)
- **Categories:** Automation, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Gumtree Property Scraper - UK Rental & Property Listings Data API
🏠 Extract structured property listings from Gumtree.com (UK) — rooms, flats, houses, and HMOs from real search URLs you control

**Pay only for the results you get!**

### 🎯 What This Scraper Does

This Apify actor scrapes **public Gumtree UK property listings** (for example *property to rent*, *rooms to rent*, and *flatshare*) straight from the **exact search results URLs** you provide. It is built for **property investors**, **lettings agents**, **operators**, **market researchers**, and **proptech teams** who want **metered, pay-for-output** pricing while still accessing Gumtree’s unique supply.

Gumtree mixes private landlords, agents, and small operators — this scraper turns those pages into **clean dataset rows** you can analyse, alert on, or load into your CRM.

### ✨ Key Features

🔍 **Search-URL driven** - Use any filtered Gumtree search URL (location, price, beds, category)  
💰 **Price intelligence** - Captures rent text, numeric price, and weekly/monthly frequency  
📐 **Weekly → monthly normalisation** - Optional `convertPwToPm` to compare pw listings on a monthly basis  
🏷️ **Rich listing fields** - Title, location, property type, availability, description, images, seller hints  
🚀 **Built for Apify** - Runs on the Apify platform with dataset export (JSON / CSV / Excel)  
🛡️ **Stable scraping patterns** - Proxy-ready input for higher volume or sensitive networks  
🧹 **Smart deduplication** - Skips listings you have already stored (toggle with `includeDuplicates`)  
💵 **Pay per result** - Store pricing follows Apify’s **per-dataset-item** model — see the Pricing tab on this actor  
📊 **Analysis-ready output** - Consistent field names and timestamps for time-series monitoring  

### 🎯 Perfect For

- **One-off comps packs** - Pay mainly for the rows you export, not a long subscription runway  
- **Buy-to-let & R2R research** - Map asking rents and supply by postcode or corridor  
- **Lettings & sourcing teams** - Feed leads into spreadsheets, Airtable, or internal tools  
- **HMO & flatshare operators** - Track rooms, shared houses, and multi-let style inventory  
- **Market spot checks** - Quick deep-dives when you do not need always-on unlimited usage  
- **Data products** - Enrich comparables with Gumtree supply on a usage-linked budget  

### 🚀 Quick Start

#### Option 1: Single Gumtree search URL (recommended)

1. Open [Gumtree property search](https://www.gumtree.com/search?search_category=property-to-rent) and apply your filters in the browser.  
2. Copy the full URL from the address bar.  
3. Paste it into `startUrls` in the Apify input JSON.

```json
{
  "startUrls": [
    {
      "url": "https://www.gumtree.com/search?search_category=property-to-rent&search_location=uk&distance=200&q=london&sort=date&max_price=2000"
    }
  ],
  "includeDuplicates": false,
  "convertPwToPm": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

#### Option 2: Multiple searches in one run

Use several URLs when you want **different geographies or strategies** in a single actor run.

```json
{
  "startUrls": [
    { "url": "https://www.gumtree.com/search?search_category=property-to-rent&search_location=uk&q=manchester" },
    { "url": "https://www.gumtree.com/search?search_category=rooms-to-rent&search_location=uk&q=birmingham" }
  ],
  "includeDuplicates": false,
  "convertPwToPm": true
}
```

### 🗺️ Where It Works

Gumtree is **UK-focused** for these categories. You are not limited to a hard-coded city list — **any valid Gumtree property / flatshare / rooms search URL** you can build in the UI will work, for example:

#### Example cities & corridors people commonly scrape

- **London & commuter belt** - Inner postcodes, boroughs, and radius-style searches
- **Manchester, Leeds, Birmingham** - Core cities and student-heavy areas
- **Bristol, Liverpool, Newcastle, Sheffield, Glasgow, Edinburgh, Cardiff** - Regional rental markets
- **Smaller towns** - Any location Gumtree returns in its search UI

#### URL tips (better data, lower cost)

- **Narrow before you scrape** - Every extra irrelevant listing may still count toward your result bill.
- **Prefer category-specific URLs** - *Property to rent*, *Rooms to rent*, and related categories each surface different inventory.
- **Avoid “national” mega-queries** unless you truly need them — they increase pages and items.

### 📊 Data Extracted

Each dataset item is one listing with fields similar to:

```json
{
  "title": "Self Contained Studios to Rent in Tooting Broadway",
  "price": "£1550",
  "location": "Tooting Broadway, London",
  "bedrooms": "7",
  "property_type": "Flat",
  "date_available": "26 Jun 2025",
  "seller_type": "Private",
  "date_posted": "2025-07-05",
  "price_value": "1550",
  "price_frequency": "pm",
  "listing_id": "1499893351",
  "url": "https://www.gumtree.com/p/property-to-rent/...",
  "description": "Prime Tooting Location - Available Now! ...",
  "seller_name": "Frank",
  "phone_number": "0798532XXXX (Click Reveal on website)",
  "images": ["https://imagedelivery.net/..."],
  "scraped_at": "2025-07-06 02:01:05"
}
```

#### Complete field list

| Field | Description | Example |
|-------|-------------|---------|
| `title` | Listing headline | `"2 bed flat near station"` |
| `price` | Rent as shown on Gumtree | `"£1200"` |
| `location` | Area / town string | `"Tooting Broadway, London"` |
| `bedrooms` | Beds as advertised | `"2"` |
| `property_type` | Flat, house, studio, etc. | `"Flat"` |
| `date_available` | Move-in text if shown | `"26 Jun 2025"` |
| `seller_type` | Private, agency, etc. | `"Private"` |
| `date_posted` | Posting date if parsed | `"2025-07-05"` |
| `price_value` | Numeric rent (string) | `"1200"` |
| `price_frequency` | `pm`, `pw`, etc. | `"pm"` |
| `listing_id` | Gumtree listing id | `"1499893351"` |
| `url` | Canonical listing URL | `https://www.gumtree.com/...` |
| `description` | Full body text | Multi-line text |
| `seller_name` | Display name if present | `"Alex"` |
| `phone_number` | Phone or masked hint | May reference Gumtree reveal |
| `images` | Array of image URLs | `["https://...", "..."]` |
| `scraped_at` | When this row was collected | ISO-style timestamp |

### ⚙️ Configuration Options

#### Core input

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `startUrls` | array | Gumtree search URLs to crawl (each item `{ "url": "..." }`) | **Required** |
| `includeDuplicates` | boolean | If `false`, skips listings already seen for your user storage | `false` |
| `convertPwToPm` | boolean | Converts weekly (`pw`) rents to approximate monthly using × 4.33 | `true` |
| `proxyConfiguration` | object | Apify proxy / custom proxy settings | Optional |

#### When to toggle options

| Goal | Suggested setting |
|------|-------------------|
| Pay as little duplicate tax as possible | `includeDuplicates`: `false` (default) |
| Force a full re-scrape of a corridor | Temporarily `includeDuplicates`: `true` |
| Fair cross-listing rent comparison | `convertPwToPm`: `true` |

### 🔧 Use Cases & Examples

#### 🏙️ City-wide “property to rent” sweep

```json
{
  "startUrls": [
    {
      "url": "https://www.gumtree.com/search?search_category=property-to-rent&search_location=uk&q=leeds&sort=date&max_price=1500"
    }
  ],
  "includeDuplicates": false,
  "convertPwToPm": true
}
```

#### 🛏️ Rooms & flatshare monitoring

```json
{
  "startUrls": [
    {
      "url": "https://www.gumtree.com/search?search_category=rooms-to-rent&search_location=uk&q=shoreditch"
    }
  ],
  "includeDuplicates": false,
  "convertPwToPm": true
}
```

#### 🧭 Multi-corridor portfolio view

```json
{
  "startUrls": [
    { "url": "https://www.gumtree.com/search?search_category=property-to-rent&q=salford" },
    { "url": "https://www.gumtree.com/search?search_category=property-to-rent&q=old+trafford" }
  ],
  "includeDuplicates": false,
  "convertPwToPm": true,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### 🆕 Product notes

- **Deduplication-aware runs** - Defaults skip previously seen ids so incremental runs focus on new stock (confirm how billing applies on the actor **Pricing** tab for your account).
- **Price frequency handling** - Surfaces `price_frequency` and optional normalisation for weekly ads.
- **Media extraction** - Collects image URLs where Gumtree exposes them in the HTML.
- **Apify-native I/O** - Standard dataset output; plug into your downstream warehouse or alerting.

### 🌟 Why Choose This Scraper?

#### ✅ Rental-market realism

Gumtree inventory often differs from portal-only sites — this actor is for teams that **need that extra supply channel**.

#### ✅ Straightforward inputs

No hidden magic: if you can click it in Gumtree, you can usually **paste the URL** and reproduce it in Apify.

#### ✅ Meter-friendly defaults

Deduplication and tight-URL guidance help you focus spend on **new or changed** inventory rather than noise.

#### ✅ Operator-friendly exports

Download **JSON, CSV, or Excel** from Apify after each run for quick sharing with non-developers.

#### ✅ Pay-per-result friendly (this listing)

Ideal when you want **usage-linked** pricing — see the **Pricing** section on this Apify actor for the exact model.

### 💼 Pricing & Usage

**Pay-per-result style listing:**

- 💵 **Pay for dataset items** - Typical Apify “per result” models charge in proportion to successful output rows (see store Pricing for this actor).
- 🎯 **Great for experiments** - Small comps jobs, pilots, or infrequent market checks.
- 🧹 **Deduplication helps** - With `includeDuplicates`: `false`, repeat runs mostly append **new** listings instead of re-billing the same stock.
- 🔎 **URL discipline = cost control** - Narrow Gumtree filters **before** you paste URLs into `startUrls`.

**Prefer flat / unlimited-style economics for the same scraper engine?**

Use the sibling listing (linked below) when you do not want per-row metering on the store page.

### 🚀 Getting Started

#### 1. Run on Apify

1. Open this actor in the Apify Store and read the **Pricing** tab.
2. Paste one or more Gumtree search URLs into `startUrls`.
3. Start the run and export the dataset when finished — you pay according to the published pricing model.

#### 2. Local development (Python)

```bash
git clone <your-repository-url>
cd gumtree-property-scraper
python -m venv .venv
.venv\Scripts\activate        ## Windows
## source .venv/bin/activate  ## macOS / Linux
pip install -r requirements.txt
python src/main.py
```

#### 3. Docker

```bash
docker build -t gumtree-property-scraper .
docker run gumtree-property-scraper
```

### 📞 Support & Contact

- 📧 **Email / ticket support** - Via your Apify Console
- 💬 **Apify community & chat** - Available from Apify’s site
- 🐛 **Issues** - Report through the actor’s Apify issue flow

### 🏷️ Keywords

gumtree scraper, gumtree property scraper pay per result, gumtree rental scraper, uk property listings scraper, rooms to rent gumtree, flatshare data, HMO listings uk, classified property data, rental market research uk, property to rent gumtree, gumtree.co.uk scraper, web scraping gumtree, apify actor pay per result, rental comps data, estate agent gumtree leads, buy to let research, R2R sourcing data, uk rental supply, property data extraction, real estate scraping uk, rental analytics, affordable gumtree data api, metered property scraping

### 📜 Legal & Compliance

✅ **Public listings only** - Scrapes content visible on Gumtree listing and search pages you target\
✅ **Respect Gumtree’s terms** - You are responsible for compliant use, rate behaviour, and account rules\
✅ **No credential stuffing** - Do not use this actor to bypass logins or paywalls\
✅ **Data protection** - Treat any personal data you receive under UK GDPR / your policies\
✅ **Ethical volume** - Prefer narrow searches, proxies, and Apify platform limits over aggressive hammering

### 🔄 Deduplication

The actor can **remember listing ids / URLs** across runs (when `includeDuplicates` is `false`) so you:

- Avoid storing the same advert repeatedly
- Keep incremental “what’s new” style datasets leaner
- Reduce wasted compute **and** redundant rows in pay-per-output scenarios

### 💡 Tips for Best Results

#### Search URLs

- Tighten **price**, **distance**, and **category** in Gumtree before copying the URL.
- Use **multiple precise URLs** instead of one gigantic national query.
- Re-copy URLs after you change filters — Gumtree encodes them in query parameters.

#### Cost-aware scheduling

- Prefer **frequent small** corridor runs over rare “whole country” pulls.
- Pair deduplication with schedules so each run mostly appends **new** ids.

#### Data quality

- Treat `phone_number` as **best-effort** — Gumtree often masks numbers until in-app reveal.
- `description` can be long — downstream tools may want truncation or NLP.

#### Performance & blocking

- Enable **Apify Proxy** (`proxyConfiguration`) if you see blocking on large sweeps.
- Split **very large** cities into multiple radius or postcode queries.

### 📄 License

MIT

### Related Actors

Looking for more UK rental data?

- [OpenRent Property Scraper | Unlimited Usage](https://apify.com/vivid-softwares/openrent-scraper) - Portal-style OpenRent listings
- [OpenRent Property Scraper | Pay Per Result](https://apify.com/vivid-softwares/openrent-property-scraper) - Pay-per-result OpenRent option
- [SpareRoom Property Scraper | Unlimited Usage](https://apify.com/vivid-softwares/spareroom-scraper) - SpareRoom flatshare & rooms
- [SpareRoom Property Scraper | Pay Per Result](https://apify.com/vivid-softwares/spareroom-property-scraper) - SpareRoom pay-per-result
- [Gumtree Property Scraper | Unlimited Usage](https://apify.com/vivid-softwares/gumtree-property-scraper) - **Same codebase**, unlimited-style store listing

***

⭐ **Need Gumtree rental supply without a long subscription commitment? Tighten your search URLs, keep deduplication on, and only pay for the fresh rows you actually need.**

# Actor input Schema

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

URLs to start scraping from (Gumtree property search results pages)

## `includeDuplicates` (type: `boolean`):

Whether to include duplicate listings in the output. When false, listings seen in previous runs are automatically skipped.

## `convertPwToPm` (type: `boolean`):

Whether to convert weekly prices (pw) to monthly prices (pm) by multiplying by 4.33. This helps normalize pricing across different listing formats.

## `proxyConfiguration` (type: `object`):

Proxy settings for the scraper to avoid IP blocking

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.gumtree.com/search?search_category=property-to-rent"
    }
  ],
  "includeDuplicates": false,
  "convertPwToPm": true,
  "proxyConfiguration": {}
}
```

# 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.gumtree.com/search?search_category=property-to-rent"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vivid-softwares/gumtree-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.gumtree.com/search?search_category=property-to-rent" }] }

# Run the Actor and wait for it to finish
run = client.actor("vivid-softwares/gumtree-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.gumtree.com/search?search_category=property-to-rent"
    }
  ]
}' |
apify call vivid-softwares/gumtree-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gumtree Property Scraper",
        "description": "UK Gumtree property scraper - property to rent, rooms & flatshare. Paste any filtered gumtree.com search URL; structured titles, prices, location, description & images. Fast HTTP, Apify Proxy, cross-run dedupe, optional pw-to-pm rent. Pay per result - R2R, lettings & comparables. JSON/CSV export.",
        "version": "1.0",
        "x-build-id": "ZpzPslXwkQy4fpz6U"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vivid-softwares~gumtree-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vivid-softwares-gumtree-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/vivid-softwares~gumtree-scraper/runs": {
            "post": {
                "operationId": "runs-sync-vivid-softwares-gumtree-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/vivid-softwares~gumtree-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-vivid-softwares-gumtree-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": "Start URLs",
                        "type": "array",
                        "description": "URLs to start scraping from (Gumtree property search results pages)",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeDuplicates": {
                        "title": "Include Duplicates",
                        "type": "boolean",
                        "description": "Whether to include duplicate listings in the output. When false, listings seen in previous runs are automatically skipped.",
                        "default": false
                    },
                    "convertPwToPm": {
                        "title": "Convert Weekly to Monthly Prices",
                        "type": "boolean",
                        "description": "Whether to convert weekly prices (pw) to monthly prices (pm) by multiplying by 4.33. This helps normalize pricing across different listing formats.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper to avoid IP blocking",
                        "default": {}
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```