# Flippa Listings Scraper (`automation-lab/flippa-listings-scraper`) Actor

Scrape public Flippa marketplace listings for prices, revenue, profit, traffic, industry, seller location, and deal-flow research.

- **URL**: https://apify.com/automation-lab/flippa-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Lead generation
- **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

## Flippa Listings Scraper

Scrape public Flippa business-for-sale listings into a clean dataset for acquisition research, market mapping, valuation comps, and deal-flow monitoring.

### What does Flippa Listings Scraper do?

Flippa Listings Scraper collects structured listings from the public Flippa marketplace.

It extracts prices, monthly revenue, monthly profit, traffic, industry, asset type, sale method, seller location, and listing URLs.

The actor is built for fast marketplace intelligence without browser automation.

It uses Flippa's public listing data and returns one row per listing.

### Who is it for?

#### Acquisition scouts and search fund analysts

Use the actor to monitor new Flippa listings every day, shortlist businesses by asking price and monthly profit, and build a repeatable first-pass diligence queue before visiting individual listing pages.

#### Business brokers and M&A advisors

Track comparable active listings by asset type, industry, location, revenue, and traffic so you can benchmark client expectations against public marketplace supply.

#### Investors and private buyers

Export public deal-flow into spreadsheets or BI tools to compare revenue multiples, verified traffic flags, sale methods, and auction end dates across many small online businesses.

#### Agencies, operators, and growth teams

Find ecommerce, content, SaaS, app, and domain opportunities that match your niche, then route candidates to internal review workflows for outreach, acquisition, or partnership analysis.

#### Data teams and automation builders

Create recurring Flippa watchlists, enrich rows with your own scoring logic, and trigger alerts when new listings meet target filters such as property type, keyword, profit, or verified traffic.

### Why use this actor?

🧭 Track active public listings without manual copying.

💰 Compare asking prices with monthly revenue and profit.

📈 Find sites with verified traffic or verified revenue.

🔎 Filter by property type, keyword, industry, and sale method.

📦 Export results to JSON, CSV, Excel, Google Sheets, or API workflows.

### What data can you extract?

| Field | Description |
| --- | --- |
| listingId | Flippa listing identifier |
| listingUrl | Public Flippa listing URL |
| title | Listing title |
| summary | Listing summary |
| propertyName | Business or asset name |
| propertyType | Flippa asset type |
| industry | Flippa industry slug |
| currentPrice | Current auction price |
| displayPrice | Displayed asking price |
| buyItNowPrice | Buy-it-now price when available |
| revenuePerMonth | Monthly revenue |
| profitPerMonth | Monthly profit |
| pageViewsPerMonth | Monthly page views |
| uniquesPerMonth | Monthly unique visitors |
| sellerLocation | Seller location |
| hasVerifiedRevenue | Whether revenue is marked verified |
| hasVerifiedTraffic | Whether traffic is marked verified |
| startsAt | Auction/listing start date |
| endsAt | Auction/listing end date |

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

The actor uses pay-per-event pricing: a small one-time start event plus a per-listing event for each dataset row saved.

| Plan tier | Start event | Per listing |
| --- | ---: | ---: |
| Free | $0.005 | $0.0000414 |
| Bronze | $0.005 | $0.0000360 |
| Silver | $0.005 | $0.00002808 |
| Gold | $0.005 | $0.00002160 |
| Platinum | $0.005 | $0.00001440 |
| Diamond | $0.005 | $0.00001008 |

Example estimates before Apify platform usage fees:

| Run size | Free tier estimate | Gold tier estimate |
| --- | ---: | ---: |
| 25 listings | about $0.0060 | about $0.0055 |
| 100 listings | about $0.0091 | about $0.0072 |
| 1,000 listings | about $0.0464 | about $0.0266 |

A small test with 25 listings is designed to stay well under one cent in actor event charges. Final billing is shown by Apify for each run and may include normal platform compute, storage, and proxy usage depending on your account plan.

### How to run it

1. Open the actor on Apify.

2. Keep the prefilled Flippa search URL or add your own Flippa search URLs.

3. Set `maxItems` to the number of listings you need.

4. Optionally choose property types, keywords, industries, or sale methods.

5. Click **Start**.

6. Download the dataset or connect it to your workflow.

### Input options

#### Flippa search URLs

Use `startUrls` when you already have a Flippa search page.

Example:

```json
{
  "startUrls": [
    { "url": "https://flippa.com/search?filter%5Bproperty_type%5D=website" }
  ],
  "maxItems": 25
}
````

#### Filter-based search

If no `startUrls` are supplied, the actor builds a search from filters.

Example:

```json
{
  "propertyTypes": ["website", "content_site"],
  "keywords": ["newsletter"],
  "status": "open",
  "maxItems": 50
}
```

#### Limits

`maxItems` controls how many listings are saved.

`pageSize` controls the API page size and is capped at 100.

Use small limits for first runs.

### Output example

```json
{
  "listingId": "12991285",
  "listingUrl": "https://flippa.com/12991285-example-listing",
  "title": "Profitable Restaurant Menu Site",
  "propertyType": "content_site",
  "industry": "food-and-drink",
  "currentPrice": 500,
  "displayPrice": 5000,
  "revenuePerMonth": 213,
  "profitPerMonth": 210,
  "pageViewsPerMonth": 20061,
  "sellerLocation": "Pakistan",
  "hasVerifiedRevenue": true,
  "hasVerifiedTraffic": true,
  "scrapedAt": "2026-06-09T08:00:00.000Z"
}
```

### Flippa property type tips

Common property types include `website`, `content_site`, and `ecommerce`.

Flippa may expose additional property type slugs over time.

You can pass any public Flippa property type string in the input.

If a filter returns no data, try a broader `startUrls` search.

### Industry filtering tips

Industry values are Flippa slugs.

Examples seen in public data include `food-and-drink`, `home-and-garden`, and similar category slugs.

Start broad, inspect the dataset, then refine industry filters.

### Data quality notes

Flippa controls the source data.

Some sellers hide or omit financial fields.

Some listings have verified revenue or verified traffic flags.

Some fields can be `null` when Flippa does not expose them for a listing.

The actor preserves numeric values as numbers where available.

### Integrations

Send new listings to Google Sheets for a daily deal-flow spreadsheet.

Push rows to Airtable for analyst review queues.

Use Make or Zapier to notify Slack when high-revenue listings appear.

Export CSV files for valuation analysis in Excel.

Use Apify webhooks to trigger downstream scoring jobs.

### 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/flippa-listings-scraper').call({
  startUrls: [{ url: 'https://flippa.com/search?filter%5Bproperty_type%5D=website' }],
  maxItems: 25,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/flippa-listings-scraper').call(run_input={
    'propertyTypes': ['website'],
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~flippa-listings-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"propertyTypes":["website"],"maxItems":25}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or other MCP-compatible tools through Apify MCP.

MCP URL:

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

Claude Code setup:

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

Claude Desktop JSON config:

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

Example prompts:

- "Find 25 open Flippa website listings and summarize the best revenue-to-price ratios."

- "Scrape Flippa content sites and flag listings with verified traffic."

- "Create a table of Flippa listings with monthly profit above zero."

### Best practices

Start with 25 to 50 listings.

Use Flippa search URLs for complex filters you create on the website.

Use filter inputs for repeatable automated runs.

Store run inputs for recurring monitoring.

Review `hasVerifiedRevenue` and `hasVerifiedTraffic` before making decisions.

### FAQ

#### Why did I get fewer listings than requested?

The source search may have fewer public listings than your `maxItems` value.

Filters can also reduce available results.

Try a broader property type or remove keyword filters.

#### Why are some financial fields null?

Some Flippa sellers do not expose all financial data publicly.

The actor does not invent values and leaves unavailable fields as `null`.

#### Why does a search URL behave differently from filters?

A `startUrls` search preserves the query parameters in the URL.

Filter inputs are only used when no `startUrls` are provided.

### Legality

This actor extracts publicly available marketplace listing data.

You are responsible for using the data lawfully.

Respect Flippa's terms, privacy rules, and applicable regulations.

Do not use scraped data for spam or unlawful outreach.

### Related scrapers

Use Flippa listings together with other automation-lab actors when building marketplace, acquisition, and competitive-intelligence workflows:

- [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews-scraper) — enrich acquisition targets or local-business niches with public review data.
- [Google Jobs Scraper](https://apify.com/automation-lab/google-jobs-scraper) — monitor hiring signals around industries or companies you are researching.
- [Apple App Store Scraper](https://apify.com/automation-lab/apple-app-store-scraper) — analyze mobile-app metadata and market signals for app and SaaS acquisition ideas.
- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) — compare ecommerce products, pricing, and marketplace opportunities.

Use Apify integrations to combine Flippa listing data with enrichment, scoring, spreadsheets, alerts, or downstream review queues.

### Changelog

#### 0.1

Initial HTTP-only Flippa listings scraper with search URL support, filter inputs, pagination, and listing-level financial and traffic metrics.

# Actor input Schema

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

Optional Flippa search or /v3/listings URLs. If provided, the actor preserves the URL filters and paginates from each URL.

## `propertyTypes` (type: `array`):

Flippa property type filters used when no start URL is supplied.

## `keywords` (type: `array`):

Optional keyword searches for Flippa listing titles and descriptions.

## `industries` (type: `array`):

Optional Flippa industry slugs such as food-and-drink, business, home-and-garden, or education.

## `status` (type: `string`):

Flippa listing status filter. Open listings are best for active deal flow.

## `saleMethods` (type: `array`):

Optional sale method filters, for example auction or classified.

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

Maximum number of Flippa listings to save.

## `pageSize` (type: `integer`):

How many listings to request per Flippa API page. Higher values reduce requests; capped at 100.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://flippa.com/search?filter%5Bproperty_type%5D=website"
    }
  ],
  "propertyTypes": [
    "website"
  ],
  "keywords": [],
  "industries": [],
  "status": "open",
  "saleMethods": [],
  "maxItems": 20,
  "pageSize": 20
}
```

# 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://flippa.com/search?filter%5Bproperty_type%5D=website"
        }
    ],
    "propertyTypes": [
        "website"
    ],
    "keywords": [],
    "industries": [],
    "status": "open",
    "saleMethods": [],
    "maxItems": 20,
    "pageSize": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/flippa-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://flippa.com/search?filter%5Bproperty_type%5D=website" }],
    "propertyTypes": ["website"],
    "keywords": [],
    "industries": [],
    "status": "open",
    "saleMethods": [],
    "maxItems": 20,
    "pageSize": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/flippa-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://flippa.com/search?filter%5Bproperty_type%5D=website"
    }
  ],
  "propertyTypes": [
    "website"
  ],
  "keywords": [],
  "industries": [],
  "status": "open",
  "saleMethods": [],
  "maxItems": 20,
  "pageSize": 20
}' |
apify call automation-lab/flippa-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flippa Listings Scraper",
        "description": "Scrape public Flippa marketplace listings for prices, revenue, profit, traffic, industry, seller location, and deal-flow research.",
        "version": "0.1",
        "x-build-id": "JRSJtJfNhM3C4khDQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~flippa-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-flippa-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~flippa-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-flippa-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~flippa-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-flippa-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",
                "properties": {
                    "startUrls": {
                        "title": "Flippa search URLs",
                        "type": "array",
                        "description": "Optional Flippa search or /v3/listings URLs. If provided, the actor preserves the URL filters and paginates from each URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Flippa property type filters used when no start URL is supplied.",
                        "default": [
                            "website",
                            "content_site",
                            "ecommerce"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Optional keyword searches for Flippa listing titles and descriptions.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "industries": {
                        "title": "Industry slugs",
                        "type": "array",
                        "description": "Optional Flippa industry slugs such as food-and-drink, business, home-and-garden, or education.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "status": {
                        "title": "Listing status",
                        "enum": [
                            "open",
                            "ended",
                            "won"
                        ],
                        "type": "string",
                        "description": "Flippa listing status filter. Open listings are best for active deal flow.",
                        "default": "open"
                    },
                    "saleMethods": {
                        "title": "Sale methods",
                        "type": "array",
                        "description": "Optional sale method filters, for example auction or classified.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Flippa listings to save.",
                        "default": 50
                    },
                    "pageSize": {
                        "title": "Page size",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many listings to request per Flippa API page. Higher values reduce requests; capped at 100.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
