# Loopnet Property Search Scraper (`ecomscrape/loopnet-property-search-scraper`) Actor

Automate commercial real estate data extraction from LoopNet.com. Collect property listings, lease information, and investment opportunities from the world's largest commercial real estate marketplace for market analysis and portfolio research.

- **URL**: https://apify.com/ecomscrape/loopnet-property-search-scraper.md
- **Developed by:** [ecomscrape](https://apify.com/ecomscrape) (community)
- **Categories:** Automation, Real estate, Developer tools
- **Stats:** 25 total users, 5 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

$15.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

## Contact

If you encounter any issues or need to exchange information, please feel free to contact us through the following link:
[My profile](https://apify.com/ecomscrape)

## LoopNet.com Property Search Scraper: Extract Commercial Real Estate Listings Efficiently

### Introduction

LoopNet.com stands as the premier online marketplace for commercial real estate, featuring millions of property listings across office spaces, retail locations, industrial facilities, land, and multifamily properties. As the most visited commercial real estate website globally, LoopNet serves investors, brokers, tenants, and property professionals seeking comprehensive market intelligence.

Manually collecting commercial property data from LoopNet is time-intensive, particularly when analyzing multiple markets, tracking investment opportunities, or conducting competitive market analysis. The LoopNet Property Search Scraper automates this process, enabling efficient extraction of property listings with detailed information for investment analysis, market research, and portfolio development.

### Scraper Overview

The LoopNet Property Search Scraper is a specialized data extraction tool designed to systematically collect commercial real estate listings from LoopNet's extensive property database. This scraper navigates through search results and extracts detailed property information including offers, descriptions, and visual assets.

The tool provides key advantages including configurable retry mechanisms for reliable data collection, flexible pagination controls for large datasets, and proxy support for uninterrupted access. It's particularly valuable for commercial real estate investors, brokers, market research analysts, and portfolio managers who need structured property data for investment decisions, competitive analysis, and market trend identification.

The scraper handles various property search parameters including location-specific queries, property types (for-lease, for-sale), and custom filters. Users can customize extraction parameters to focus on specific geographic markets, property categories, or price ranges relevant to their investment criteria.

### Input and Output Details

### Input Configuration Explained

Example url 1: https://www.loopnet.com/search/commercial-real-estate/london-england--united-kingdom/for-lease/

Example url 2: https://www.loopnet.com/search/commercial-real-estate/manchester-gtm--united-kingdom/for-lease/?view=map

Example url 3: https://www.loopnet.com/search/commercial-real-estate/for-lease/?sk=fc398b85076b46b0ff98496a53eb4c6e&bb=to_kjztm7B1g35ixI&loc=Amsterdam%252C%2520Netherlands
    
Example Screenshot of bussiness list by query page:
    
![](https://i.ibb.co/pjp11pTr/Screenshot-from-2026-01-06-17-19-14.png)

#### Input Format

The scraper accepts JSON configuration for precise control over data extraction:
```json
{
  "proxy": {
    "useApifyProxy": false
  },
  "ignore_url_failures": true,
  "max_retries_per_url": 2,
  "max_items_per_url": 20,
  "urls": [
    "https://www.loopnet.com/search/commercial-real-estate/london-england--united-kingdom/for-lease/",
    "https://www.loopnet.com/search/commercial-real-estate/new-york-ny/office-space/for-sale/",
    "https://www.loopnet.com/search/commercial-real-estate/los-angeles-ca/retail-space/for-lease/"
  ]
}
````

**The `urls` parameter**: Add URLs of LoopNet property search pages you want to scrape. Navigate to LoopNet, configure your search with desired filters (location, property type, lease/sale status, price range), then copy the resulting URL. You can paste URLs individually or use Bulk edit for prepared lists.

**The `max_items_per_url` parameter**: Limit the number of properties to scrape per URL. Default value is 20, balancing data collection volume with processing efficiency.

**The `max_retries_per_url` parameter**: Set retry attempts for each URL if scraping fails due to network issues or detection. Default is 2 retries, providing reliability without excessive delays.

**The `ignore_url_failures` parameter**: When `true`, the scraper continues running even if some URLs fail after maximum retries. This prevents one problematic URL from stopping your entire scraping job.

**The `proxy` parameter**: Configure proxy settings to maintain access and avoid detection. Essential for large-scale data collection or when scraping multiple markets simultaneously.

#### Output Format

The scraper returns structured property data with the following fields:

- **Offers**: Comprehensive offer details including lease terms, sale prices, square footage, and financial information. *Critical for investment analysis, deal comparison, and financial modeling. Enables quick assessment of property economics and investment viability.*

- **Name**: Property name or address identifier. *Essential for property identification, tracking listings across time, and organizing data in CRM or investment databases.*

- **Description**: Detailed property description including features, amenities, location highlights, and specifications. *Provides context for investment decisions, reveals property condition and capabilities, and supports due diligence processes.*

- **URL**: Direct link to the full property listing on LoopNet. *Valuable for accessing complete property details, contacting listing brokers, viewing additional photos, and conducting deeper research.*

- **Image**: Property image URL for visual reference. *Enables quick visual assessment of property condition, supports presentation materials, and enriches investment databases with visual assets.*

Each field serves specific purposes in commercial real estate workflows, investment analysis, market research, and portfolio management strategies.

##### Example Output:

```json
[
  {
  "offers": [
    {
      "offered_by": {
        "works_for": {
          "@type": "Organization",
          "name": "Victor Harris Commercial"
        },
        "@type": "Person",
        "name": "Lloyd Harris"
      },
      "price": "$120.95 SF/YR",
      "price_currency": "USD",
      "availability": "https://schema.org/InStock",
      "@type": "Offer"
    }
  ],
  "name": "103-105 Bunhill Row, London EC1Y 8LZ",
  "description": "13,000 SF Office Building Offered at $120.95 SF/YR in London EC1Y 8LZ",
  "url": "https://www.loopnet.com/Listing/103-105-Bunhill-Row-London/38114023/",
  "image": "https://images1.loopnet.com/i2/F37uVS9-DXqTqx3dDz9NO_-7p-ASc96N7niYLN6XUPU/106/office-property-for-lease-103-105-bunhill-row-london-lnd-ec1y-8lz.jpg",
  "from_url": "https://www.loopnet.com/search/commercial-real-estate/london-england--united-kingdom/for-lease/"
}
]
```

### Usage Guide

#### Setting Up Property Searches

To effectively use the LoopNet scraper, start by constructing targeted property search URLs on LoopNet.com that match your investment criteria.

**Step 1: Define Search Parameters on LoopNet**

Navigate to LoopNet.com and configure your search using available filters:

- **Location**: City, state, region, or specific address
- **Property Type**: Office, retail, industrial, land, multifamily, specialty
- **Transaction Type**: For Lease, For Sale
- **Price Range**: Minimum and maximum lease rates or sale prices
- **Size**: Square footage requirements
- **Building Class**: Class A, B, or C

**Step 2: Copy Search URLs**

After configuring filters and viewing results, copy the URL from your browser's address bar. This URL contains all your search parameters and will be used for scraping.

**Step 3: Configure JSON Input**

Add copied URLs to the `urls` array in your configuration. Set appropriate values for:

- `max_items_per_url`: Based on how many properties you need per search
- `max_retries_per_url`: Keep at 2 for standard reliability
- `ignore_url_failures`: Set to `true` for multi-URL scraping jobs
- `proxy`: Configure if experiencing access issues or scraping large volumes

#### Best Practices

**URL Construction:**

- Test search URLs manually before adding to scraper configuration
- Use specific location filters rather than broad geographic searches for better results
- Include property type filters to focus on relevant listings
- Verify URLs return expected results before bulk scraping

**Data Collection Strategy:**

- Start with smaller `max_items_per_url` values (20-50) to test configuration
- Monitor extraction progress for any blocked requests
- Implement delays between large scraping sessions
- Use proxy rotation for high-volume data collection

**Market Coverage:**

- Create separate URL lists for different property types within a market
- Run parallel scrapes for multiple markets with appropriate delays
- Track collected properties to avoid duplicates across sessions
- Store results with timestamps for historical market analysis

#### Common Troubleshooting

**Access Issues:**

- Enable proxy configuration if encountering access restrictions
- Verify URLs are correctly formatted and publicly accessible
- Check that property listings are active (not expired or removed)
- Adjust retry settings if experiencing intermittent connection issues

**Empty Results:**

- Verify search URL returns results when accessed manually in browser
- Check if property filters are too restrictive
- Confirm location spelling and formatting in URL
- Try broader search parameters if specific queries return no data

**Data Quality:**

- Validate that extracted offers contain expected fields
- Check image URLs are accessible and valid
- Verify property descriptions are complete
- Cross-reference sample results with actual LoopNet listings

### Benefits and Applications

The LoopNet Property Search Scraper delivers significant time savings for commercial real estate professionals. What typically requires hours of manual browsing and data recording is reduced to minutes of automated extraction.

**Primary Applications:**

**Investment Deal Flow**: Build comprehensive property databases for investment analysis, track new listings in target markets, compare deals across locations, and identify off-market opportunities through listing pattern analysis.

**Market Research**: Conduct comparative market analysis across multiple geographies, analyze rental rates and cap rates by property type and location, identify market trends through historical data collection, and benchmark portfolio properties against market comparables.

**Brokerage Intelligence**: Monitor competitor listings and pricing strategies, track inventory levels by market and property type, identify potential clients through listing patterns, and maintain updated market knowledge for client advisory services.

**Portfolio Management**: Track properties of interest across multiple markets, monitor lease expiration dates and renewal opportunities, analyze comparable properties for valuation purposes, and maintain databases for portfolio optimization decisions.

**The scraper provides competitive advantages through:**

- Systematic access to commercial property data across multiple markets
- Complete property information including financial terms and specifications
- Visual assets for property assessment and presentation materials
- Scalable research capabilities supporting both individual deals and market-wide analysis
- Time efficiency enabling focus on analysis rather than data collection

The structured output integrates seamlessly with CRM systems, investment analysis tools, and commercial real estate databases, enabling immediate use of collected data for investment decisions and market intelligence.

### Conclusion

The LoopNet Property Search Scraper transforms manual commercial real estate research into efficient automated data collection. By providing structured access to LoopNet's extensive property database, it empowers investors, brokers, and analysts to make data-driven decisions and accelerate their market research processes.

Whether you're sourcing investment opportunities, conducting market analysis, tracking competitive listings, or building comprehensive property databases, this scraper provides the systematic data extraction capabilities needed to enhance your commercial real estate operations.

Ready to streamline your commercial real estate data collection? Start extracting valuable property insights from LoopNet today and transform your investment research and market analysis capabilities.

- [**Loopnet Property Details Scraper**](https://apify.com/ecomscrape/loopnet-bussiness-details-scraper): A specialized data extraction tool engineered to harvest detailed bussiness information from loopnet's bussiness marketplace.

## Your feedback

We are always working to improve Actors' performance. So, if you have any technical feedback about loopnet.com Property Search Scraper or simply found a bug, please create an issue on the Actor's Issues tab in Apify Console.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the bussiness list page urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `max_items_per_url` (type: `integer`):

Limit the number of items per URL you want to scrape

## `max_retries_per_url` (type: `integer`):

Limit the number of retries for each URL if the scrape is detected as a bot or the page fails to load

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to load after the maximum number of retries is reached.

## `proxy` (type: `object`):

Select proxies to be used by your scraper.

## Actor input object example

```json
{
  "urls": [
    "https://www.loopnet.com/search/commercial-real-estate/london-england--united-kingdom/for-lease/"
  ],
  "max_items_per_url": 20,
  "max_retries_per_url": 2,
  "ignore_url_failures": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "urls": [
        "https://www.loopnet.com/search/commercial-real-estate/london-england--united-kingdom/for-lease/"
    ],
    "max_items_per_url": 20,
    "max_retries_per_url": 2,
    "ignore_url_failures": true,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ecomscrape/loopnet-property-search-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 = {
    "urls": ["https://www.loopnet.com/search/commercial-real-estate/london-england--united-kingdom/for-lease/"],
    "max_items_per_url": 20,
    "max_retries_per_url": 2,
    "ignore_url_failures": True,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("ecomscrape/loopnet-property-search-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 '{
  "urls": [
    "https://www.loopnet.com/search/commercial-real-estate/london-england--united-kingdom/for-lease/"
  ],
  "max_items_per_url": 20,
  "max_retries_per_url": 2,
  "ignore_url_failures": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call ecomscrape/loopnet-property-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Loopnet Property Search Scraper",
        "description": "Automate commercial real estate data extraction from LoopNet.com. Collect property listings, lease information, and investment opportunities from the world's largest commercial real estate marketplace for market analysis and portfolio research.",
        "version": "0.0",
        "x-build-id": "Q5opsDxzXSehebZao"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ecomscrape~loopnet-property-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ecomscrape-loopnet-property-search-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/ecomscrape~loopnet-property-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ecomscrape-loopnet-property-search-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/ecomscrape~loopnet-property-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ecomscrape-loopnet-property-search-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": {
                    "urls": {
                        "title": "URLs of the bussiness list page urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the bussiness list page urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "max_items_per_url": {
                        "title": "Limit the number of items per URL",
                        "type": "integer",
                        "description": "Limit the number of items per URL you want to scrape"
                    },
                    "max_retries_per_url": {
                        "title": "Limit the number of retries for each URL",
                        "type": "integer",
                        "description": "Limit the number of retries for each URL if the scrape is detected as a bot or the page fails to load"
                    },
                    "ignore_url_failures": {
                        "title": "Ignore URL failures",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to load after the maximum number of retries is reached."
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your scraper."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```