# BusinessesForSale Listings Scraper (`automation-lab/businessesforsale-listings-scraper`) Actor

Extract public BusinessesForSale listings with prices, revenue, cash-flow hints, locations, descriptions, images, seller details, and listing URLs.

- **URL**: https://apify.com/automation-lab/businessesforsale-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## BusinessesForSale Listings Scraper

Extract public business-for-sale listings from BusinessesForSale.com search, category, country, franchise, and detail pages.

Use this actor to turn acquisition-search pages into clean datasets with titles, locations, asking prices, revenue hints, cash flow, descriptions, listing URLs, images, tags, and optional detail-page enrichment.

### What does BusinessesForSale Listings Scraper do?

BusinessesForSale Listings Scraper collects public listing cards from BusinessesForSale.com.

It is built for lead sourcing and market-comps workflows where you need structured rows rather than manually opening dozens of search result pages.

The actor starts from one or more BusinessesForSale URLs and follows pagination until it reaches your `maxItems` limit or `maxPagesPerStartUrl` safety cap.

### Who is it for?

- 🧭 Acquisition entrepreneurs building shortlists of SMB opportunities.
- 💼 M&A analysts comparing asking prices and revenue hints across markets.
- 🏢 Business brokers tracking competing listings and franchise inventory.
- 📊 Market researchers monitoring sectors, countries, and price bands.
- 🔔 Deal origination teams that need repeatable, exportable lead lists.

### Why use this actor?

Manual listing research is slow and inconsistent.

This actor gives you repeatable extraction with a clear input, a structured dataset, and Apify integrations for exports, webhooks, schedules, and APIs.

You can run it daily or weekly to monitor new public listings without copying data by hand.

### Key features

- Extracts public BusinessesForSale listing cards.
- Supports search, category, country, franchise, and filtered URLs.
- Captures asking price, revenue, cash flow, franchise fee, and investment fields when shown.
- Saves listing URL, contact URL, image URL, tags, labels, and source URL.
- Optional detail-page enrichment for longer descriptions and seller metadata.
- Pagination support with a configurable page cap.
- Runs HTTP-first without a browser for lower compute cost.

### Example start URLs

Use any public BusinessesForSale search page, for example:

```text
https://www.businessesforsale.com/search/businesses-for-sale
https://www.businessesforsale.com/search/franchise-businesses-for-sale
https://uk.businessesforsale.com/uk/search/businesses-for-sale
https://www.businessesforsale.com/search/work-from-home-businesses-for-sale
````

### Data fields

| Field | Description |
| --- | --- |
| `listingId` | Listing identifier when discoverable from listing or shortlist URLs. |
| `title` | Public listing title. |
| `url` | Canonical listing detail URL. |
| `sourceUrl` | Search/category page where the listing was found. |
| `location` | Public location text. |
| `listingType` | Business, franchise, or similar label. |
| `labels` | Result badges such as New, Business, or Franchise. |
| `askingPrice` | Asking price text when shown. |
| `revenue` | Revenue or turnover text when shown. |
| `cashFlow` | Cash-flow or net-profit text when shown. |
| `franchiseFee` | Franchise fee text when shown. |
| `investment` | Investment text when shown. |
| `financials` | Raw finance label/value map for fields not mapped to first-class columns. |
| `description` | Short search-card description. |
| `detailDescription` | Longer public detail-page description when enabled. |
| `sellerName` | Public seller/broker name when available. |
| `sellerType` | Public seller schema type when available. |
| `contactUrl` | Public contact page URL. |
| `imageUrl` | Listing image URL. |
| `tags` | Listing tags such as relocatable or work from home. |
| `scrapedAt` | ISO timestamp when the row was saved. |

### How much does it cost to scrape BusinessesForSale listings?

This actor uses pay-per-event pricing.

Current pricing is a $0.005 run-start event plus tiered per-listing pricing: FREE $0.000052054, BRONZE $0.000045265, SILVER $0.000035306, GOLD $0.000027159, PLATINUM $0.000018106, and DIAMOND $0.000012674 per saved listing.

The default input is intentionally modest so your first run is cheap.

For large monitoring jobs, start with a small `maxItems` value, inspect the data, then increase the limit.

### Input settings

#### Start URLs

Add one or more BusinessesForSale URLs.

The best inputs are search or category pages because they contain pagination.

#### Maximum listings

`maxItems` controls the total number of rows saved across all start URLs.

#### Open listing detail pages

Enable `includeDetails` when you need longer descriptions or seller metadata.

Keep it disabled for fast, cheap market scans.

#### Maximum pages per start URL

`maxPagesPerStartUrl` prevents unexpectedly large runs.

Use it together with `maxItems` for predictable costs.

#### Proxy configuration

The actor runs without proxy by default.

If your run is rate limited, enable Apify Proxy in the advanced section.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.businessesforsale.com/search/businesses-for-sale" }
  ],
  "maxItems": 100,
  "maxPagesPerStartUrl": 4,
  "includeDetails": false,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### Example output

```json
{
  "listingId": "3968829",
  "title": "Work From Home Profitable Clothing E-Commerce Store",
  "url": "https://uk.businessesforsale.com/uk/work-from-home-profitable-clothing-e-commerce-store.aspx",
  "sourceUrl": "https://www.businessesforsale.com/search/businesses-for-sale",
  "location": "UK",
  "listingType": "Business",
  "askingPrice": "£5,900",
  "revenue": "£20,000",
  "cashFlow": "£1,600",
  "description": "Profitable Clothing E-Commerce Store...",
  "imageUrl": "https://www.businessesforsale.com/uploadsstatic/a3968829mediumthumbnail.jpg",
  "tags": ["Relocatable", "Work From Home"],
  "scrapedAt": "2026-06-24T04:54:54.900Z"
}
```

### How to scrape BusinessesForSale listings

1. Open the actor on Apify.
2. Paste one or more BusinessesForSale search URLs.
3. Set `maxItems` to the number of listings you need.
4. Decide whether to enable detail-page enrichment.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or via API.

### Tips for better results

- Use filtered BusinessesForSale URLs for more targeted datasets.
- Keep `includeDetails` off for broad scans.
- Enable `includeDetails` for final shortlists.
- Schedule recurring runs for monitoring workflows.
- Use `sourceUrl` to separate rows from multiple markets or categories.

### Common workflows

#### M\&A lead sourcing

Run one or more category pages weekly and export rows to a CRM or spreadsheet.

#### Broker inventory monitoring

Track competing listings by sector and location.

#### Market comps

Compare asking prices, revenue hints, and cash-flow hints across segments.

#### Franchise research

Use franchise search URLs to collect franchise fees, investment ranges, and location data.

### Integrations

Apify datasets can be consumed by:

- Google Sheets automations.
- Zapier or Make scenarios.
- CRM imports.
- BI dashboards.
- Data warehouses.
- Slack or email alerts via webhooks.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/businessesforsale-listings-scraper').call({
  startUrls: [{ url: 'https://www.businessesforsale.com/search/businesses-for-sale' }],
  maxItems: 100,
  maxPagesPerStartUrl: 4,
  includeDetails: false
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/businessesforsale-listings-scraper").call(run_input={
    "startUrls": [{"url": "https://www.businessesforsale.com/search/businesses-for-sale"}],
    "maxItems": 100,
    "maxPagesPerStartUrl": 4,
    "includeDetails": False,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~businessesforsale-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{"url":"https://www.businessesforsale.com/search/businesses-for-sale"}],
    "maxItems": 100,
    "maxPagesPerStartUrl": 4,
    "includeDetails": false
  }'
```

### MCP integration

Use this actor from Claude Code, Claude Desktop, or other MCP clients through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/businessesforsale-listings-scraper
```

Claude Code setup:

```bash
claude mcp add apify-businessesforsale "https://mcp.apify.com/?tools=automation-lab/businessesforsale-listings-scraper"
```

Claude Desktop JSON config:

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

Example prompts:

- “Run the BusinessesForSale listings scraper for UK businesses and summarize the top acquisition targets.”
- “Compare asking prices and cash-flow hints for the latest franchise listings.”
- “Export new work-from-home business listings into a spreadsheet.”

### Scheduling

Create an Apify schedule to run the same search URLs daily, weekly, or monthly.

For monitoring workflows, keep the input focused and use downstream deduplication by `url` or `listingId`.

### Limits and caveats

BusinessesForSale pages may omit some finance fields.

The actor returns only fields that are public on the page.

Some detail pages may have shorter public seller metadata than others.

### FAQ

#### Can I scrape a country or category page?

Yes. Paste any public BusinessesForSale search, country, category, franchise, or filtered URL into `startUrls`.

#### Does the actor contact sellers?

No. It only extracts public page data and never submits inquiry forms.

### Troubleshooting

#### Why are some price or revenue fields missing?

The listing page did not publish that field, or it uses a label that is only preserved in the raw `financials` object.

#### Why is my run slower with detail pages enabled?

Detail enrichment opens one extra page per listing. Disable `includeDetails` for broad scans.

#### What if I get rate limited?

Reduce run size, increase the page cap gradually, or enable Apify Proxy in the advanced input section.

### Legality and responsible use

This actor extracts publicly available listing information.

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

Do not use this actor to submit contact forms, spam sellers, or bypass private access controls.

### Related scrapers

Explore other Automation Lab actors for lead sourcing, company research, real estate, and market intelligence:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/zillow-scraper
- https://apify.com/automation-lab/realestate-scraper

### Changelog

#### 0.1

Initial version for public BusinessesForSale search/category extraction with optional detail enrichment.

# Actor input Schema

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

BusinessesForSale search or category URLs, such as global business-for-sale, franchise, country, sector, or filtered pages.

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

Maximum number of listing records to save across all start URLs.

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

When enabled, the actor visits each public listing detail page to enrich records with longer descriptions and seller metadata when available.

## `maxPagesPerStartUrl` (type: `integer`):

Safety limit for pagination from each search/category URL. Leave the default for normal lead lists.

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

Optional Apify Proxy settings. The default runs without proxy; enable proxies only if your run is rate limited.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.businessesforsale.com/search/businesses-for-sale"
    }
  ],
  "maxItems": 20,
  "includeDetails": false,
  "maxPagesPerStartUrl": 4,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.businessesforsale.com/search/businesses-for-sale"
        }
    ],
    "maxItems": 20,
    "includeDetails": false,
    "maxPagesPerStartUrl": 4,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/businessesforsale-listings-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.businessesforsale.com/search/businesses-for-sale" }],
    "maxItems": 20,
    "includeDetails": False,
    "maxPagesPerStartUrl": 4,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/businessesforsale-listings-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.businessesforsale.com/search/businesses-for-sale"
    }
  ],
  "maxItems": 20,
  "includeDetails": false,
  "maxPagesPerStartUrl": 4,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/businessesforsale-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BusinessesForSale Listings Scraper",
        "description": "Extract public BusinessesForSale listings with prices, revenue, cash-flow hints, locations, descriptions, images, seller details, and listing URLs.",
        "version": "0.1",
        "x-build-id": "ImJkppgeRlrqXBauO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~businessesforsale-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-businessesforsale-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~businessesforsale-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-businessesforsale-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~businessesforsale-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-businessesforsale-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "BusinessesForSale search or category URLs, such as global business-for-sale, franchise, country, sector, or filtered pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listing records to save across all start URLs.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Open listing detail pages",
                        "type": "boolean",
                        "description": "When enabled, the actor visits each public listing detail page to enrich records with longer descriptions and seller metadata when available.",
                        "default": false
                    },
                    "maxPagesPerStartUrl": {
                        "title": "Maximum pages per start URL",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety limit for pagination from each search/category URL. Leave the default for normal lead lists.",
                        "default": 4
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. The default runs without proxy; enable proxies only if your run is rate limited."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```