# OnTheMarket Property Scraper (`automation-lab/onthemarket-property-scraper`) Actor

Scrape public OnTheMarket UK property listings with prices, agents, coordinates, images, labels, and optional detail-page descriptions.

- **URL**: https://apify.com/automation-lab/onthemarket-property-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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 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

## OnTheMarket Property Scraper

Scrape public OnTheMarket property listings from UK search pages and listing detail pages.

Use this actor to collect property prices, addresses, bedroom counts, agent contact details, images, coordinates, listing labels, and optional long-form descriptions from OnTheMarket.

### What does OnTheMarket Property Scraper do?

OnTheMarket Property Scraper extracts structured property data from public pages on `onthemarket.com`.

It reads search result pages such as London houses for sale and optionally visits individual property detail pages for richer information.

The output is a clean dataset that can be exported as JSON, CSV, Excel, XML, RSS, or HTML from Apify.

### Who is it for?

🏡 Real estate analysts use it to monitor local property supply and asking prices.

📈 Investors use it to compare areas, property types, and price bands.

🏢 Estate agencies use it to benchmark competing listings and agent coverage.

🧭 Relocation teams use it to collect available housing options in target cities.

🧪 Data teams use it to feed property intelligence dashboards and enrichment workflows.

### Why use this actor?

The actor converts OnTheMarket pages into a normalized dataset.

You do not need to manually copy prices, addresses, links, and agent details from the website.

You can schedule the actor to run daily or weekly and track market changes over time.

### Main use cases

- Track property listings in a location
- Collect comparable homes for pricing analysis
- Monitor newly added and reduced listings
- Build local property supply dashboards
- Enrich internal CRM records with public listing URLs
- Compare agent inventory by branch
- Export property data for spreadsheet analysis

### How much does it cost to scrape OnTheMarket properties?

This actor uses pay-per-event pricing.

There is a small start event per run and a per-result event for each property listing saved.

| Event | Free tier | Bronze | Silver | Gold | Platinum | Diamond |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Run start | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Property listing saved | $0.00115 | $0.00100 | $0.00078 | $0.00060 | $0.00040 | $0.00028 |

Example actor charges before any Apify platform credits or plan-specific terms:

| Listings saved | Free tier estimate | Bronze estimate |
| ---: | ---: | ---: |
| 20 listings | $0.028 | $0.025 |
| 100 listings | $0.120 | $0.105 |
| 1,000 listings | $1.155 | $1.005 |

The prefilled input is intentionally small (`maxItems: 20`, `maxPages: 2`), so first tests are usually only a few cents of actor charges.

Apify Free plan users can run small tests using their included monthly platform credits; for predictable spend, start with 20 results, review the dataset, and then increase `maxItems` for production monitoring.

For larger monitoring jobs, set `maxItems` and `maxPages` to match the number of listings you actually need.

### Input options

You can provide either full OnTheMarket URLs or a location slug.

`startUrls` accepts search pages and detail pages.

`locationSlug` can build a URL such as `https://www.onthemarket.com/for-sale/property/london/`.

`searchType` supports sale and rental searches.

`maxItems` limits the total dataset rows.

`maxPages` limits pagination per search URL.

`includeDetails` turns on detail-page enrichment.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.onthemarket.com/for-sale/property/london/" }
  ],
  "maxItems": 20,
  "maxPages": 2,
  "includeDetails": false
}
````

### Output data

Each dataset item represents one property listing.

The actor stores listing metadata, agent data, media links, coordinates, and scrape metadata.

Optional detail mode can add descriptions and key information fields such as tenure or service charges when they are exposed on the listing page.

### Output field table

| Field | Description |
| --- | --- |
| `listing_id` | OnTheMarket listing identifier |
| `title` | Listing headline |
| `price` | Displayed listing price |
| `price_qualifier` | Price qualifier such as guide price |
| `address` | Public listing address |
| `property_type` | Property type label |
| `bedrooms` | Bedroom count |
| `bathrooms` | Bathroom count |
| `features` | Bullet-point features |
| `description` | Detail-page description when enabled |
| `key_info` | Detail-page key information object |
| `agent_name` | Listing agent or branch name |
| `agent_phone` | Public agent phone number |
| `agent_branch_url` | Agent branch page URL |
| `agent_logo_url` | Agent logo image URL |
| `latitude` | Listing latitude when available |
| `longitude` | Listing longitude when available |
| `image_urls` | Listing image URLs |
| `detail_url` | Listing detail URL |
| `source_url` | Search or detail page that produced the row |
| `days_since_added_or_reduced` | Added/reduced text from the site |
| `label` | Listing label such as Reduced |
| `is_reduced` | Boolean reduced flag |
| `is_recently_added` | Boolean recently-added flag |
| `scraped_at` | ISO timestamp of scraping |

### Example output

```json
{
  "listing_id": "18740866",
  "title": "3 bedroom flat for sale",
  "price": "£390,000",
  "price_qualifier": "Guide price",
  "address": "Headlam Street, London, E1",
  "property_type": "Flat",
  "bedrooms": 3,
  "bathrooms": 1,
  "agent_name": "Bairstow Eves - Bow",
  "latitude": 51.52193,
  "longitude": -0.057377,
  "detail_url": "https://www.onthemarket.com/details/18740866/"
}
```

### How to scrape OnTheMarket search pages

1. Open OnTheMarket in your browser.
2. Search for a location, sale/rent type, or property category.
3. Copy the search result URL.
4. Paste it into `startUrls`.
5. Choose `maxItems` and `maxPages`.
6. Run the actor.
7. Export the dataset from Apify.

### How to scrape OnTheMarket detail pages

You can also paste individual property URLs into `startUrls`.

Detail URLs usually look like `/details/18740866/`.

When the actor receives a detail URL, it extracts the detail-page property data directly.

This is useful when you already have a list of known listings.

### Tips for best results

Use one or a few targeted search URLs per run.

Keep `maxItems` low while testing.

Increase `maxPages` only when you need deeper pagination.

Enable `includeDetails` when descriptions and key-info fields matter more than speed.

Disable `includeDetails` for faster market snapshots from search pages.

### Integrations

Send results to Google Sheets for quick property review.

Load CSV exports into Excel for price analysis.

Connect the dataset to BigQuery, Snowflake, or a data warehouse using Apify integrations.

Trigger the actor from Make or Zapier when your workflow needs fresh market data.

Use webhooks to notify your system when a monitoring run finishes.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/onthemarket-property-scraper').call({
  startUrls: [{ url: 'https://www.onthemarket.com/for-sale/property/london/' }],
  maxItems: 20,
  maxPages: 2
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/onthemarket-property-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.onthemarket.com/for-sale/property/london/'}],
    'maxItems': 20,
    'maxPages': 2,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~onthemarket-property-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.onthemarket.com/for-sale/property/london/"}],"maxItems":20,"maxPages":2}'
```

### MCP access

Use this actor from MCP-compatible tools through the Apify MCP server.

Claude Code example MCP URL:

`https://mcp.apify.com/?tools=automation-lab/onthemarket-property-scraper`

Add it from Claude Code with:

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

Claude Desktop can use this JSON configuration:

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

Example prompts:

- “Scrape 20 OnTheMarket listings in London and summarize price ranges.”
- “Find recently reduced flats from this OnTheMarket URL.”
- “Collect property listings and return agent names and phone numbers.”

### Scheduling

Schedule the actor on Apify to monitor the same market regularly.

Daily runs can help detect new supply and price reductions.

Weekly runs are useful for slower trend reporting.

Use consistent input URLs if you want comparable time-series data.

### Data freshness

The actor scrapes live public pages when the run starts.

The `scraped_at` field records when each row was saved.

OnTheMarket content can change at any time, especially prices, availability, and agent details.

### Limitations

The actor can only scrape public pages that OnTheMarket returns to the run.

Some listings may have missing fields if OnTheMarket does not expose them in page data.

Detail-page enrichment is slower because it requests one extra page per listing.

The actor does not bypass login-only or private content.

### FAQ

#### Can I scrape both sale and rental listings?

Yes. Use a sale or rental URL in `startUrls`, or set `searchType` to `for-sale` or `to-rent` when using `locationSlug`.

#### Does this actor visit every detail page?

Only when `includeDetails` is enabled. Search-only mode is faster and still returns core listing fields.

### Troubleshooting

If you receive fewer results than expected, increase `maxPages` or check whether the source search has enough listings.

If a search URL returns no data, open it in a browser and confirm it is a valid OnTheMarket URL.

If detail descriptions are missing, enable `includeDetails`.

If the run is slow, disable detail mode and scrape from search pages only.

### Legality and responsible use

This actor is designed to extract publicly available information from OnTheMarket pages.

You are responsible for using the data in compliance with applicable laws, website terms, and privacy rules.

Do not use scraped data for unlawful discrimination, harassment, spam, or other prohibited activities.

### Related scrapers

You may also find these Automation Lab actors useful:

- https://apify.com/automation-lab/zillow-scraper
- https://apify.com/automation-lab/airbnb-listing
- https://apify.com/automation-lab/booking-scraper
- https://apify.com/automation-lab/rightmove-scraper
- https://apify.com/automation-lab/realla-scraper

### Changelog

Initial version extracts OnTheMarket search and detail-page property data using HTTP and embedded JSON.

# Actor input Schema

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

OnTheMarket search result URLs or individual property detail URLs. Example: https://www.onthemarket.com/for-sale/property/london/

## `locationSlug` (type: `string`):

Optional OnTheMarket location slug used when Start URLs are empty, e.g. london, manchester, bristol.

## `searchType` (type: `string`):

Build generated location URLs for properties for sale or to rent.

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

Maximum number of property listings to save.

## `maxPages` (type: `integer`):

How many paginated search result pages to visit for each search URL.

## `includeDetails` (type: `boolean`):

Open each property detail page to enrich results with description and key-info fields. Slower but richer.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.onthemarket.com/for-sale/property/london/"
    }
  ],
  "locationSlug": "london",
  "searchType": "for-sale",
  "maxItems": 20,
  "maxPages": 2,
  "includeDetails": false
}
```

# Actor output Schema

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

No description

# 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.onthemarket.com/for-sale/property/london/"
        }
    ],
    "locationSlug": "london"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/onthemarket-property-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.onthemarket.com/for-sale/property/london/" }],
    "locationSlug": "london",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/onthemarket-property-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.onthemarket.com/for-sale/property/london/"
    }
  ],
  "locationSlug": "london"
}' |
apify call automation-lab/onthemarket-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OnTheMarket Property Scraper",
        "description": "Scrape public OnTheMarket UK property listings with prices, agents, coordinates, images, labels, and optional detail-page descriptions.",
        "version": "0.1",
        "x-build-id": "CT8iLqPLAsQRlHpRw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~onthemarket-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-onthemarket-property-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~onthemarket-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-onthemarket-property-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~onthemarket-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-onthemarket-property-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "OnTheMarket search result URLs or individual property detail URLs. Example: https://www.onthemarket.com/for-sale/property/london/",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "locationSlug": {
                        "title": "Location slug",
                        "type": "string",
                        "description": "Optional OnTheMarket location slug used when Start URLs are empty, e.g. london, manchester, bristol."
                    },
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "for-sale",
                            "to-rent"
                        ],
                        "type": "string",
                        "description": "Build generated location URLs for properties for sale or to rent.",
                        "default": "for-sale"
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of property listings to save.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum result pages per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many paginated search result pages to visit for each search URL.",
                        "default": 2
                    },
                    "includeDetails": {
                        "title": "Visit listing detail pages",
                        "type": "boolean",
                        "description": "Open each property detail page to enrich results with description and key-info fields. Slower but richer.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```