# Flippa Scraper | 💰 $0.5 / 1K (`solidcode/flippa-scraper`) Actor

Reliable, cheap and effective.
Extract detailed data from Flippa.com digital asset listings — financials, traffic metrics, valuation multiples, verification badges, and sale status for websites, SaaS, apps, and domains.

- **URL**: https://apify.com/solidcode/flippa-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

Extract detailed listing data from Flippa.com — the world's largest marketplace for buying and selling websites, SaaS businesses, apps, domains, and eCommerce stores. Get financial metrics, traffic data, verification badges, sale status, and **50+ data fields** for every listing.

### Why This Scraper?

- **50+ structured fields per listing** — financials, traffic, verification badges, sale details, and more
- **Built-in filters** — Filter by property type (SaaS, eCommerce, App, Domain, AI Tools, and more) and listing status without constructing complex URLs
- **Price drop detection** — Identify reduced listings with original price, current price, and drop percentage
- **Verified data flags** — Know which listings have verified revenue, verified traffic, and Super Seller badges
- **Clean, deduplicated output** — One consistent field per data point, no legacy duplicates or empty fields
- **Flexible input** — Use search URLs from your browser, direct listing URLs, or the built-in filters — or combine all three
- **Low cost** — Runs on datacenter proxies by default, keeping your costs down

### Use Cases

**Investment Research & Due Diligence**
- Screen thousands of digital assets by revenue, profit margin, and valuation multiples
- Compare asking prices across similar property types and categories
- Track price drops to find motivated sellers and negotiation opportunities

**Market Intelligence**
- Analyze SaaS, eCommerce, and content site valuations over time
- Benchmark revenue multiples and profit multiples by industry and property type
- Monitor listing volume and pricing trends across asset categories

**Deal Sourcing & Brokerage**
- Build a pipeline of listings matching specific investment criteria
- Identify verified, high-quality listings with strong financials
- Track auction activity, bid counts, and time-to-sale patterns

**Competitive Analysis**
- Discover what types of digital businesses are selling and at what prices
- Analyze monetization methods, platforms, and site ages across listings
- Study which categories attract the most bids and watchers

### Getting Started

#### Browse All Active Listings

The simplest way to start — no URLs needed. Just set how many results you want:

```json
{
    "maxResults": 100
}
````

#### Filter by Property Type

Find specific types of digital assets:

```json
{
    "propertyType": "saas",
    "status": "open",
    "maxResults": 200
}
```

#### Use a Flippa Search URL

Apply filters on Flippa.com in your browser, then paste the URL:

```json
{
    "searchUrls": [
        "https://flippa.com/search?filter[property_type]=established&filter[status]=open&filter[revenue]=revenue_generating"
    ],
    "maxResults": 500
}
```

#### Scrape Specific Listings

Provide direct listing URLs to get full data for specific assets:

```json
{
    "listingUrls": [
        "https://flippa.com/12345678",
        "https://flippa.com/87654321"
    ]
}
```

#### Combine Everything

Mix search URLs, listing URLs, and filters in a single run:

```json
{
    "searchUrls": ["https://flippa.com/buy/sitetype/saas"],
    "listingUrls": ["https://flippa.com/12345678"],
    "propertyType": "ecommerce",
    "status": "won",
    "maxResults": 1000
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchUrls` | string\[] | `[]` | Flippa search or category page URLs. Apply filters on Flippa.com first, then copy the URL from your browser |
| `listingUrls` | string\[] | `[]` | Direct URLs to specific Flippa listings (e.g., `https://flippa.com/12345678`) |

#### Filters & Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of listings to extract. Set to 0 for no limit |
| `propertyType` | string | All Types | Filter by asset type: Website, SaaS, eCommerce, App, Domain Only, AI Apps & Tools, Content Site, Marketplace, or Service Business |
| `status` | string | Active Listings | Choose Active Listings, Sold Listings, or All Listings |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `proxyConfiguration` | object | Apify Proxy | Proxy settings for reliable data collection. The defaults work for most cases |

### Output

Each listing contains up to 50+ structured fields. Here's an example:

```json
{
    "id": "12345678",
    "url": "https://flippa.com/12345678",
    "title": "Profitable SaaS Platform - Project Management Tool",
    "summary": "Established SaaS with 500+ paying customers and 85% gross margin",
    "propertyType": "SaaS",
    "category": "Internet",
    "primaryPlatform": "Custom Built",
    "propertyName": "projecttool.io",
    "monetization": "Subscription",
    "siteAge": "3 years",
    "businessLocation": "United States",
    "price": 150000,
    "priceFormatted": "USD $150,000",
    "originalPrice": 175000,
    "priceDrop": true,
    "priceDropPercent": 14,
    "currency": "USD $",
    "monthlyRevenue": 12500,
    "annualRevenue": 150000,
    "ttmRevenue": 145000,
    "monthlyProfit": 9400,
    "annualProfit": 112800,
    "profitMargin": 75.2,
    "monthlyExpenses": 3100,
    "revenueMultiple": 1.0,
    "profitMultiple": 1.33,
    "uniqueVisitorsPerMonth": 45000,
    "annualOrganicTraffic": 380000,
    "authorityScore": 32,
    "saleMethod": "classified",
    "saleMethodTitle": "Asking Price",
    "status": "open",
    "bidCount": 5,
    "endDate": "2026-05-15T00:00:00Z",
    "underOffer": false,
    "openToOffer": true,
    "isVerified": true,
    "hasVerifiedTraffic": true,
    "hasVerifiedRevenue": true,
    "isSuperSeller": false,
    "isBrokerSeller": false,
    "isEditorsChoice": true,
    "isSponsored": false,
    "isConfidential": false,
    "isManagedByFlippa": false,
    "isReadyMade": false,
    "isDomainOnly": false,
    "equitySalePercent": "100",
    "verifications": [
        {"provider": "google_analytics", "description": "Traffic verified via Google Analytics"}
    ],
    "integrations": ["google_analytics", "stripe"],
    "searchUrl": "https://flippa.com/buy/sitetype/saas",
    "scrapedAt": "2026-04-12T10:30:00.000Z"
}
```

#### All Available Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique listing identifier |
| `url` | string | Direct URL to the listing page |
| `title` | string | Listing headline |
| `summary` | string | Short description of the listing |
| `propertyType` | string | Asset type (SaaS, eCommerce, Website, App, etc.) |
| `category` | string | Industry category (Internet, Business, etc.) |
| `primaryPlatform` | string | Platform the asset is built on (WordPress, Shopify, Custom Built, etc.) |
| `propertyName` | string | Name or domain of the property |
| `monetization` | string | Revenue method (Subscription, Ads, Affiliate, eCommerce, etc.) |
| `siteAge` | string | How long the site has existed (e.g., "3 years") |
| `businessLocation` | string | Business location (e.g., "United States") |
| `price` | number | Current asking or sale price |
| `priceFormatted` | string | Formatted price with currency (e.g., "USD $150,000") |
| `originalPrice` | number | Original price before any reduction |
| `priceDrop` | boolean | Whether the price has been reduced |
| `priceDropPercent` | number | Percentage of price reduction |
| `currency` | string | Currency label (e.g., "USD $") |
| `monthlyRevenue` | number | Average monthly revenue |
| `annualRevenue` | number | Annual revenue (monthly x 12) |
| `ttmRevenue` | number | Trailing twelve months revenue |
| `monthlyProfit` | number | Average monthly net profit |
| `annualProfit` | number | Annual net profit (monthly x 12) |
| `profitMargin` | number | Profit margin as a percentage |
| `monthlyExpenses` | number | Average monthly expenses |
| `revenueMultiple` | number | Valuation multiple based on revenue |
| `profitMultiple` | number | Valuation multiple based on profit |
| `uniqueVisitorsPerMonth` | number | Monthly unique visitors |
| `annualOrganicTraffic` | number | Annual organic search traffic |
| `authorityScore` | number | SEO authority score |
| `saleMethod` | string | Sale method ("auction" or "classified") |
| `saleMethodTitle` | string | Human-readable sale method (e.g., "Asking Price") |
| `status` | string | Listing status ("open" or "won") |
| `bidCount` | number | Number of bids placed |
| `endDate` | string | Listing end date (ISO 8601) |
| `underOffer` | boolean | Whether an offer is pending |
| `openToOffer` | boolean | Whether the seller accepts offers |
| `isVerified` | boolean | Listing verified by Flippa |
| `hasVerifiedTraffic` | boolean | Traffic stats are independently verified |
| `hasVerifiedRevenue` | boolean | Financial stats are independently verified |
| `isSuperSeller` | boolean | Seller has Super Seller badge |
| `isBrokerSeller` | boolean | Listed by a broker |
| `isEditorsChoice` | boolean | Editor's Choice pick |
| `isSponsored` | boolean | Sponsored or promoted listing |
| `isConfidential` | boolean | Confidential listing (requires NDA) |
| `isManagedByFlippa` | boolean | Managed by Flippa team |
| `isReadyMade` | boolean | Turnkey/starter site |
| `isDomainOnly` | boolean | Domain-only sale |
| `equitySalePercent` | string | Percentage of equity being sold |
| `verifications` | array | Verification badges with provider and description |
| `integrations` | array | Connected services (e.g., "google\_analytics", "stripe") |
| `searchUrl` | string | The search URL that found this listing |
| `scrapedAt` | string | Timestamp of when data was collected (ISO 8601) |

### Tips for Best Results

- **Start with filters** — Use the Property Type and Listing Status dropdowns instead of manually constructing URL query strings
- **Use search URLs for complex filters** — Apply advanced filters on Flippa.com (revenue range, price range, site age, etc.) then paste the URL
- **Combine inputs** — Mix search URLs for broad discovery with direct listing URLs for specific assets you're tracking
- **Check verification flags** — Filter your results by `isVerified`, `hasVerifiedRevenue`, and `hasVerifiedTraffic` to focus on higher-quality listings
- **Monitor price drops** — Use the `priceDrop` and `priceDropPercent` fields to find motivated sellers

### Pricing

**~$0.50 per 1,000 listings** — among the lowest prices on Apify for marketplace data.

| Results | Estimated Cost |
|---------|----------------|
| 100 | ~$0.05 |
| 1,000 | ~$0.50 |
| 10,000 | ~$5.00 |

Platform fees (compute, proxy, storage) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Custom API integrations
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate investment research, market intelligence, and business analysis. Users are responsible for complying with applicable laws and Flippa's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste Flippa search or category page URLs here. Apply filters on Flippa.com first, then copy the URL from your browser. Example: https://flippa.com/buy/sitetype/saas

## `listingUrls` (type: `array`):

Direct URLs to specific Flippa listings. Example: https://flippa.com/12345678

## `maxResults` (type: `integer`):

Maximum number of listings to extract. Set to 0 for no limit. Recommended: 100-1000 to keep costs reasonable.

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

Filter by the type of digital asset. Leave on 'All Types' to include everything.

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

Choose whether to collect active listings, sold listings, or both.

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

Proxy settings for reliable data collection. The default settings work for most cases.

## Actor input object example

```json
{
  "searchUrls": [],
  "listingUrls": [],
  "maxResults": 100,
  "propertyType": "",
  "status": "open",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Table of scraped listings with key financial and status fields.

## `detail` (type: `string`):

All extracted fields for each listing.

# 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 = {
    "searchUrls": [],
    "listingUrls": [],
    "maxResults": 100,
    "propertyType": "",
    "status": "open",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/flippa-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 = {
    "searchUrls": [],
    "listingUrls": [],
    "maxResults": 100,
    "propertyType": "",
    "status": "open",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/flippa-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 '{
  "searchUrls": [],
  "listingUrls": [],
  "maxResults": 100,
  "propertyType": "",
  "status": "open",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call solidcode/flippa-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flippa Scraper | 💰 $0.5 / 1K",
        "description": "Reliable, cheap and effective.\nExtract detailed data from Flippa.com digital asset listings — financials, traffic metrics, valuation multiples, verification badges, and sale status for websites, SaaS, apps, and domains.",
        "version": "1.0",
        "x-build-id": "qVcVYwuR0R9CxIlPB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~flippa-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-flippa-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/solidcode~flippa-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-flippa-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/solidcode~flippa-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-flippa-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": {
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Paste Flippa search or category page URLs here. Apply filters on Flippa.com first, then copy the URL from your browser. Example: https://flippa.com/buy/sitetype/saas",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingUrls": {
                        "title": "Listing URLs",
                        "type": "array",
                        "description": "Direct URLs to specific Flippa listings. Example: https://flippa.com/12345678",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to extract. Set to 0 for no limit. Recommended: 100-1000 to keep costs reasonable.",
                        "default": 100
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "",
                            "website",
                            "saas",
                            "ecommerce",
                            "app",
                            "domain",
                            "ai_apps_and_tools",
                            "content",
                            "marketplace",
                            "service"
                        ],
                        "type": "string",
                        "description": "Filter by the type of digital asset. Leave on 'All Types' to include everything.",
                        "default": ""
                    },
                    "status": {
                        "title": "Listing Status",
                        "enum": [
                            "open",
                            "won",
                            "open,won"
                        ],
                        "type": "string",
                        "description": "Choose whether to collect active listings, sold listings, or both.",
                        "default": "open"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for reliable data collection. The default settings work for most cases."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```