# LandAndFarm Scraper: Listings, Prices, Acreage & Broker Leads (`getascraper/landandfarm-scraper`) Actor

Scrape LandAndFarm.com land listings across all 50 US states. Returns asking price, price per acre, acreage, property type, county, and full broker contact details (name, company, phone, email). Spreadsheet-ready output.

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

## Pricing

from $1.12 / 1,000 land listings

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

## LandAndFarm scraper: US land listings and broker leads

Get live US land listings from LandAndFarm: price, acreage, price per acre, full photo galleries, and complete broker contact details, ready for your spreadsheet without any cleanup.

**LandAndFarm** is one of the largest US land marketplaces, listing hundreds of thousands of rural parcels from land brokers, ranch specialists, and timberland consultants. This scraper turns any LandAndFarm search page or property page into clean, structured rows you can open in Excel, Google Sheets, or your own database.

### What does LandAndFarm scraper do?

You give it a state, a property type, and price or acreage limits, or paste direct LandAndFarm links. It returns one clean row per property with the asking price, lot size, computed price per acre, location down to county level, the full list of photos, and complete broker contact details. Missing values are left blank rather than guessed, so the data stays trustworthy.

### Why use LandAndFarm scraper?

Land investors, brokerages, and analysts need normalized, current listing data to find deals and reach sellers. This scraper supports:

* **Market and price analysis:** Compare price per acre across states, counties, and land types to spot under-priced parcels.
* **Broker lead generation:** Build a contact list of active rural land brokers with names, companies, phone numbers, and websites.
* **Land inventory tracking:** Monitor active listings, acreage, and listing dates across regions for investment decisions.

### Who is this for?

* **I am a land investor** comparing acreage prices across several states, so I can find under-priced parcels using price per acre and county location.
* **I am a real estate brokerage** building a contact list of active rural land brokers, so I can reach out across specific states and land categories.
* **I am a timberland analyst** tracking forestry parcels, so I can review acreage, location, and price per acre for investment decisions.
* **I am a lead generation manager** sourcing real estate prospects, so I can collect broker phone numbers, websites, and active listing details in bulk.

### How to use LandAndFarm scraper

1. **Choose your search:** Paste direct LandAndFarm search or property links, or leave the link field empty to use the state and type filters.
2. **Pick state and type:** Select a US state and an optional land category, such as farms, ranches, hunting land, or timberland.
3. **Set price and acreage limits:** Filter by minimum and maximum price and acreage.
4. **Set a limit:** Choose how many listings to return.
5. **Run it:** Start the scraper and download your rows as Excel, CSV, JSON, or HTML.

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `startUrls` | array of URLs | No | Direct LandAndFarm search or property links. Leave empty to use the state and type filters below. |
| `stateFilter` | enum | No | Two letter US state code to search, such as TX, FL, or SC. Leave empty for no state filter. |
| `propertyType` | enum | No | Restrict results to one land category, such as farms, ranches, hunting land, or timberland. Leave empty for all types. |
| `minPrice` | integer | No | Minimum asking price in US dollars. Use 0 for no minimum. |
| `maxPrice` | integer | No | Maximum asking price in US dollars. Use 0 for no maximum. |
| `minAcres` | number | No | Minimum lot size in acres. Use 0 for no minimum. |
| `maxAcres` | number | No | Maximum lot size in acres. Use 0 for no maximum. |
| `maxItems` | integer | No | Maximum number of listings to save in one run. Defaults to 100. |
| `proxyConfiguration` | object | No | Proxy settings. US residential proxies are required for reliable results and are set as the default. |

### Output

Each property becomes one flat row with the full photo gallery and broker details.

**Example output**

```json
{
  "title": "92.53 Acres in Laurens, SC - $1,860,000",
  "price": 1860000,
  "priceText": "$1,860,000",
  "pricePerAcre": 20101.59,
  "acres": 92.53,
  "city": "Laurens",
  "state": "South Carolina",
  "stateAbbreviation": "SC",
  "county": "Laurens County",
  "zip": "29360",
  "streetAddress": "672 Boxwood Road",
  "latitude": 34.49,
  "longitude": -82.01,
  "propertyType": "Farms",
  "propertyTypesAll": "Farms, Residential Land, Hunting Land",
  "beds": 3,
  "baths": 3.5,
  "homeSqft": 3000,
  "hasHouse": true,
  "description": "92.53 acre farm with custom home, pasture, and pond.",
  "imageCount": 46,
  "primaryImageUrl": "https://assets.landandfarm.com/resizedimages/800/0/h/80/1-5445374106",
  "images": [
    "https://assets.landandfarm.com/resizedimages/800/0/h/80/1-5445374106",
    "https://assets.landandfarm.com/resizedimages/800/0/h/80/1-5445374177"
  ],
  "listingDate": "2025-03-14",
  "brokerName": "Rusty Hamrick",
  "brokerCompany": "Huff Creek Properties",
  "brokerPhone": "(864) 230-0694",
  "brokerEmail": "rusty@huffcreekproperties.com",
  "brokerWebsite": "www.huffcreekproperties.com",
  "propertyUrl": "https://www.landandfarm.com/property/ervindale-farm-36928340/",
  "scrapedAt": "2026-06-28T12:51:53.941Z"
}
````

### Data table

| Field | Type | Description |
| --- | --- | --- |
| `title` | string | Listing headline. |
| `price` | number | Asking price in US dollars. |
| `priceText` | string | Asking price as a display string. |
| `pricePerAcre` | number | Price divided by acreage, computed for you. |
| `acres` | number | Lot size in acres. |
| `city` | string | City or nearest town. |
| `state` | string | Full state name. |
| `stateAbbreviation` | string | Two letter state code. |
| `county` | string | County name. |
| `zip` | string | ZIP code. |
| `streetAddress` | string | Street address, when listed. |
| `latitude` | number | Map latitude. |
| `longitude` | number | Map longitude. |
| `propertyType` | string | Primary land category. |
| `propertyTypesAll` | string | All land categories, comma separated. |
| `beds` | number | Bedroom count, for parcels with a home. |
| `baths` | number | Bathroom count, half baths counted as 0.5. |
| `homeSqft` | number | Home interior square footage, 0 for vacant land. |
| `hasHouse` | boolean | True when the parcel includes a home. |
| `description` | string | Full listing description. |
| `imageCount` | number | Total number of photos. |
| `primaryImageUrl` | string | Main cover photo. |
| `images` | array of strings | Every photo in the listing gallery. |
| `listingDate` | string | Date the listing first appeared. |
| `brokerName` | string | Listing agent name. |
| `brokerCompany` | string | Listing brokerage name. |
| `brokerPhone` | string | Listing agent phone number. |
| `brokerEmail` | string | Listing agent email, when public. |
| `brokerWebsite` | string | Listing agent website. |
| `propertyUrl` | string | Direct link to the listing. |
| `scrapedAt` | string | Timestamp of when the row was collected. |

### Pricing

This scraper uses pay per result billing. You are charged only for listings successfully saved to your dataset. Empty runs and blocked requests cost nothing. There are no monthly subscriptions and no fixed fees. Set a `maxItems` value to keep every run within budget.

### FAQ, disclaimers, and support

##### Does it get blocked?

No. The scraper routes through US residential connections and handles the site's security checks automatically, so runs complete reliably without any setup from you.

##### Does it extract private owner details?

No. It collects only the publicly visible broker and brokerage details shown on listings. It does not access private owner contact information behind any login.

##### How fresh is the data?

Every row is collected live at the moment you run the scraper. There is no cached or stale data.

##### Why is a field sometimes empty?

Land listings vary in detail. When a value is genuinely missing, the field is left blank rather than filled with a placeholder, so your data stays accurate.

### Legal

This scraper collects only data that is publicly visible on LandAndFarm. It does not access private accounts or bypass any login. Users are responsible for complying with local privacy regulations and the website's terms of service. LandAndFarm is a trademark of its owner. This is an independent tool and is not affiliated with, endorsed by, or sponsored by LandAndFarm.

### Support

Open an issue on the Issues tab for any bug, question, or feature request. We respond within 48 hours.

# Actor input Schema

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

Direct LandAndFarm search or property URLs. Leave empty to use the State Filter + Property Type combination.

## `stateFilter` (type: `string`):

Optional 2-letter US state code (e.g. 'TX', 'FL', 'SC'). Empty = no state filter.

## `propertyType` (type: `string`):

Restrict to a single land category. Empty = all types.

## `minPrice` (type: `integer`):

Minimum asking price in USD. 0 = no minimum.

## `maxPrice` (type: `integer`):

Maximum asking price in USD. 0 = no maximum.

## `minAcres` (type: `number`):

Minimum acreage. 0 = no minimum.

## `maxAcres` (type: `number`):

Maximum acreage. 0 = no maximum.

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

Maximum number of listings to save. Hard ceiling for the run.

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

Proxy settings. LandAndFarm sits behind Akamai Bot Manager and requires US residential proxies to bypass. The default is mandatory for reliable extraction.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.landandfarm.com/search/South-Carolina-land-for-sale/"
    }
  ],
  "stateFilter": "",
  "propertyType": "",
  "minPrice": 0,
  "maxPrice": 0,
  "minAcres": 0,
  "maxAcres": 0,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

One row per scraped LandAndFarm property listing, flattened for spreadsheet import.

# 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.landandfarm.com/search/South-Carolina-land-for-sale/"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/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 = {
    "startUrls": [{ "url": "https://www.landandfarm.com/search/South-Carolina-land-for-sale/" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/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 '{
  "startUrls": [
    {
      "url": "https://www.landandfarm.com/search/South-Carolina-land-for-sale/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call getascraper/landandfarm-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LandAndFarm Scraper: Listings, Prices, Acreage & Broker Leads",
        "description": "Scrape LandAndFarm.com land listings across all 50 US states. Returns asking price, price per acre, acreage, property type, county, and full broker contact details (name, company, phone, email). Spreadsheet-ready output.",
        "version": "0.0",
        "x-build-id": "H5uBz0hORCu2j6gX5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~landandfarm-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-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/getascraper~landandfarm-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-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/getascraper~landandfarm-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-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",
                "required": [
                    "proxyConfiguration"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Direct LandAndFarm search or property URLs. Leave empty to use the State Filter + Property Type combination.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "stateFilter": {
                        "title": "Filter by State",
                        "enum": [
                            "",
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY"
                        ],
                        "type": "string",
                        "description": "Optional 2-letter US state code (e.g. 'TX', 'FL', 'SC'). Empty = no state filter.",
                        "default": ""
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "",
                            "farms",
                            "residential-land",
                            "hunting-land",
                            "recreational-land",
                            "waterfront",
                            "timberland",
                            "ranches",
                            "commercial"
                        ],
                        "type": "string",
                        "description": "Restrict to a single land category. Empty = all types.",
                        "default": ""
                    },
                    "minPrice": {
                        "title": "Min Total Price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum asking price in USD. 0 = no minimum.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Max Total Price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum asking price in USD. 0 = no maximum.",
                        "default": 0
                    },
                    "minAcres": {
                        "title": "Min Acres",
                        "minimum": 0,
                        "type": "number",
                        "description": "Minimum acreage. 0 = no minimum.",
                        "default": 0
                    },
                    "maxAcres": {
                        "title": "Max Acres",
                        "minimum": 0,
                        "type": "number",
                        "description": "Maximum acreage. 0 = no maximum.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Max Listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to save. Hard ceiling for the run.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. LandAndFarm sits behind Akamai Bot Manager and requires US residential proxies to bypass. The default is mandatory for reliable extraction.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
