# Land and Farm Scraper — US Land, Farms & Ranches for Sale (`haketa/landandfarm-scraper`) Actor

Scrape LandAndFarm.com rural real estate across the US. Extract price, acreage, price-per-acre, full address, description, photos and URL for land, farms, ranches and country homes. Filter by state or search URL. Export JSON/CSV/Excel for land investing and market research.

- **URL**: https://apify.com/haketa/landandfarm-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 results

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

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

## What's an Apify Actor?

Actors are 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

## Land and Farm Scraper — US Land, Farms & Ranches for Sale

Extract structured rural real-estate data from **LandAndFarm.com**, one of the largest US marketplaces for land, farms, ranches, hunting property and country homes. Search by state — or paste any LandAndFarm search URL — and get clean, ready-to-use records for every listing: **price, acreage, price-per-acre, full address, description, photos and listing URL**.

No code, no login, no API key. Run it from the Apify Console, on a schedule, or from your own app via the API. Results download as **JSON, CSV, Excel, HTML or XML**, or sync straight into Google Sheets, Airtable, Make, Zapier and n8n.

> **🌾 Built for land investing & market research.** Every listing includes **acreage and an auto-calculated price-per-acre** — the metric land investors and appraisers actually compare on.

---

### 📋 What this scraper does

LandAndFarm lists hundreds of thousands of rural properties across all 50 states. This actor turns a search into a clean, structured dataset you can analyse, monitor or feed into another system.

Give it one or more states (for example `Texas`, `Montana`, `Colorado`), and it will:

- ✅ Collect every listing from the search results, page after page
- ✅ Return the **numeric price** and a formatted price string
- ✅ Parse the **acreage** and compute **price-per-acre** automatically
- ✅ Break out the **full location** — street, city, state, ZIP and country
- ✅ Capture the **listing description**, main photo and detail-page URL
- ✅ De-duplicate every property by its listing URL

Because the data comes straight from the page's structured data, runs are fast, cheap and reliable — hundreds of listings in seconds.

---

### ⭐ Why choose this scraper

- **Price-per-acre, done for you.** The single most important land metric, computed on every listing so you can compare properties instantly.
- **Clean, structured location.** Street, city, state and ZIP as separate fields for mapping and county-level analysis.
- **Whole-market coverage.** Land, farms, ranches, hunting land and country homes across every US state.
- **Fast and economical.** Pure structured-data extraction — a few hundred listings finish in seconds at very low cost.
- **Underserved niche.** Rural-land data is rarely available in clean, structured form — perfect for a differentiated data product.

---

### 💡 Popular use cases

| Use case | How this scraper helps |
| --- | --- |
| **Land investing** | Compare price-per-acre across counties and states to spot undervalued parcels. |
| **Market research** | Measure supply, median price and $/acre for any rural market. |
| **Appraisal & comps** | Build comparable-sales lists by location and acreage. |
| **Farm & ranch sourcing** | Find farms, ranches and hunting land matching size and budget. |
| **Real-estate analytics** | Feed a clean rural-property feed into BI tools, dashboards or a database. |
| **Lead & deal flow** | Track new listings by state for acquisition pipelines. |

---

### 🚀 Quick start

1. Open the actor in the Apify Console.
2. In **States**, enter one or more states, e.g. `Texas`, `Colorado`.
3. Set **Max items** (default 100) and click **Start**.
4. Download your data from the **Storage → Dataset** tab.

For farms, ranches, country homes, a county, or price/acreage filters, build the search on landandfarm.com and paste the URL into **Start URLs** instead.

---

### ⚙️ Input

| Field | Type | Description |
| --- | --- | --- |
| **States** | array | US states to scrape (land for sale), e.g. `["Texas", "Montana"]`. |
| **Start URLs** | array | Paste full LandAndFarm search URLs to scrape directly — the best way to target farms, ranches, homes, a county, or price/acreage filters. Overrides States. |
| **Max items** | integer | Maximum number of listings to collect. Default 100. |
| **Proxy** | object | Apify Proxy (US) is recommended and on by default. |

#### Example 1 — By state

```json
{ "states": ["Texas", "Oklahoma"], "maxItems": 300 }
````

#### Example 2 — Farms in a state (Start URL)

```json
{
  "startUrls": ["https://www.landandfarm.com/search/farms-for-sale/texas/"],
  "maxItems": 200
}
```

#### Example 3 — Filtered search (build on the site, paste the URL)

```json
{
  "startUrls": ["https://www.landandfarm.com/search/montana-land-for-sale/"],
  "maxItems": 500
}
```

***

### 📦 Output

Each listing becomes one dataset record:

```json
{
  "listingId": "35226642",
  "title": "758 acres, Hondo, TX 78861",
  "price": 15995000,
  "priceText": "$15,995,000",
  "acres": 758,
  "pricePerAcre": 21102,
  "streetAddress": null,
  "city": "Hondo",
  "state": "TX",
  "zipCode": "78861",
  "country": "US",
  "description": "Two Creeks Ranch — a premier hunting and cattle ranch with...",
  "imageUrl": "https://assets.landandfarm.com/resizedimages/...",
  "url": "https://www.landandfarm.com/property/two-creeks-ranch-35226642/",
  "searchLocation": "Texas",
  "scrapedAt": "2026-07-01T12:43:00.000Z"
}
```

#### Output fields

| Field | Description |
| --- | --- |
| `listingId` | LandAndFarm listing ID. |
| `title` | Listing title (acreage + address). |
| `price` | Price as a number, in USD. `null` when the listing has no public price. |
| `priceText` | Formatted price. |
| `acres` | Lot size in acres. |
| `pricePerAcre` | Price divided by acreage (USD/acre). |
| `streetAddress` / `city` / `state` / `zipCode` / `country` | Full location. |
| `description` | Listing description. |
| `imageUrl` | Main photo. |
| `url` | Listing detail page. |
| `searchLocation` | The state or URL that produced this record. |
| `scrapedAt` | Extraction timestamp. |

***

### 🗺️ Popular states for land & farm data

Land investing and rural-property demand is strongest in these states — all supported directly via the **States** field:

| State | Typical use |
| --- | --- |
| **Texas** | Ranches, hunting land, recreational acreage — the largest US land market. |
| **Montana** | Large ranches, timberland and recreational land. |
| **Colorado** | Mountain land, ranches and recreational parcels. |
| **Florida** | Farmland, groves and development land. |
| **Tennessee** | Farms, homesteads and hunting land. |
| **Oklahoma** | Ranch land and mineral-rights acreage. |
| **Georgia** | Timberland, farms and hunting tracts. |
| **Missouri / Arkansas** | Affordable farmland and recreational land. |
| **California** | Vineyards, orchards and agricultural land. |
| **Kentucky** | Horse farms, cattle land and homesteads. |

You can run several states in a single job — each is paginated and de-duplicated automatically.

### 🌲 Property types you can collect

LandAndFarm spans the full rural spectrum. The **States** field targets land-for-sale; for the rest, paste a site search URL into **Start URLs**:

- **Raw / vacant land** — undeveloped parcels by the acre
- **Farms** — cropland, pasture, orchards, groves and dairies
- **Ranches** — cattle, horse and mixed-use ranches
- **Hunting land** — recreational and hunting tracts
- **Timberland** — forested and investment timber parcels
- **Country homes** — rural homes on acreage
- **Waterfront & recreational** — lakefront, riverfront and recreational property

### 📈 What you can analyze

- **Price-per-acre benchmarks** by county, state or property type
- **Supply trends** — how many parcels are on the market and at what size
- **Undervalued parcels** — sort by `pricePerAcre` to surface deals
- **Comparable sales** — build comps by location and acreage
- **Market entry** — size a rural market before buying or listing

***

### 🧭 Tips for best results

- **Compare on price-per-acre**, not just price — it normalises across parcel sizes and is the field investors sort on.
- **Use Start URLs for anything beyond land-for-sale** — farms, ranches, country homes, counties and price/acreage filters are all preserved in the site URL.
- **Scale by state:** run multiple states in one run; each is paginated automatically.
- **Rural addresses:** many land parcels have no street address (only city/county) — that's normal for raw land, and city/state/ZIP are still captured.

***

### 🔌 Integrations & export

- **Download formats:** JSON, CSV, Excel, HTML, XML, RSS.
- **Google Sheets / Airtable / Make / Zapier / n8n:** push results automatically after each run.
- **API:** start runs and fetch data with the Apify API or the JavaScript / Python clients.
- **Scheduling:** run weekly to track new rural listings and price movements over time.

#### Run via API (example)

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR~landandfarm-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "states": ["Texas"], "maxItems": 200 }'
```

***

### ❓ FAQ

**Do I need an account or API key?**
No. You only need an Apify account.

**How is price-per-acre calculated?**
It's the listing price divided by its acreage, computed for every listing that has both values.

**Can I scrape farms and ranches too?**
Yes — build that search on landandfarm.com and paste the URL into Start URLs. The States field targets land-for-sale.

**Why do some listings have no street address?**
Raw land often has no street number — only a city and county. The scraper still captures city, state and ZIP.

**Does it return duplicates?**
No. Every listing is de-duplicated by its URL within a run.

***

### ⚖️ Legal & responsible use

This actor collects **publicly available** information from LandAndFarm.com listing pages — the same data any visitor can see. It does not bypass logins or access private data.

You are responsible for how you use the data. Please respect LandAndFarm's Terms of Use and applicable law, and use the data for lawful purposes such as market research, analytics and property analysis.

***

### 🛟 Support

Need a field added or hit an issue? Open a ticket from the actor's **Issues** tab and include your input configuration — most requests are quick to address.

Happy land hunting! 🌾

### 📅 Changelog & Maintenance

**Last updated:** 2026-07-02 — Actor verified and maintained. Data pipeline tested for quality, structure and freshness; selectors/endpoints confirmed against the live site.

# Actor input Schema

## `states` (type: `array`):

US states to scrape land listings for, e.g. 'Texas', 'California', 'Montana'. Each state is scraped as land-for-sale. For farms, ranches, homes or price/acreage filters, use Start URLs instead.

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

Paste full LandAndFarm.com search URLs to scrape directly — the best way to target farms, ranches, country homes, a county, or price/acreage filters. Build the search on landandfarm.com and copy the URL here (e.g. https://www.landandfarm.com/search/farms-for-sale/texas/). Overrides States when provided.

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

Maximum number of listings to collect across all searches. Default 100.

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

Proxy configuration. Apify Proxy (US) is recommended for reliable, geo-correct results.

## Actor input object example

```json
{
  "states": [
    "Colorado",
    "Montana"
  ],
  "startUrls": [
    "https://www.landandfarm.com/search/farms-for-sale/texas/"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `listingId` (type: `string`):

LandAndFarm listing ID

## `title` (type: `string`):

Listing title

## `price` (type: `string`):

Listing price in USD

## `priceText` (type: `string`):

Formatted price

## `acres` (type: `string`):

Lot size in acres

## `pricePerAcre` (type: `string`):

Price divided by acres

## `streetAddress` (type: `string`):

Street address

## `city` (type: `string`):

City / locality

## `state` (type: `string`):

State

## `zipCode` (type: `string`):

Postal code

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

Country

## `description` (type: `string`):

Listing description

## `imageUrl` (type: `string`):

Main image URL

## `url` (type: `string`):

Listing detail page URL

## `searchLocation` (type: `string`):

Search used

## `scrapedAt` (type: `string`):

Extraction timestamp

# 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 = {
    "states": [
        "Texas"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/landandfarm-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 = {
    "states": ["Texas"],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/landandfarm-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 '{
  "states": [
    "Texas"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/landandfarm-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Land and Farm Scraper — US Land, Farms & Ranches for Sale",
        "description": "Scrape LandAndFarm.com rural real estate across the US. Extract price, acreage, price-per-acre, full address, description, photos and URL for land, farms, ranches and country homes. Filter by state or search URL. Export JSON/CSV/Excel for land investing and market research.",
        "version": "0.1",
        "x-build-id": "D5r792c7nTwe8ne4P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~landandfarm-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-landandfarm-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/haketa~landandfarm-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-landandfarm-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/haketa~landandfarm-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-landandfarm-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": {
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "US states to scrape land listings for, e.g. 'Texas', 'California', 'Montana'. Each state is scraped as land-for-sale. For farms, ranches, homes or price/acreage filters, use Start URLs instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (optional)",
                        "type": "array",
                        "description": "Paste full LandAndFarm.com search URLs to scrape directly — the best way to target farms, ranches, country homes, a county, or price/acreage filters. Build the search on landandfarm.com and copy the URL here (e.g. https://www.landandfarm.com/search/farms-for-sale/texas/). Overrides States when provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to collect across all searches. Default 100.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy configuration. Apify Proxy (US) is recommended for reliable, geo-correct results.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```