# ApolloDuck Scraper & Market Intelligence (`marielise.dev/apolloduck-scraper-intelligence`) Actor

Scrape ApolloDuck listings with structured filters or natural-language AI search. Extract boats, barges, narrowboats, prices, specs, sellers, and photos, then generate buyer, seller, or broker-style market intelligence reports.

- **URL**: https://apify.com/marielise.dev/apolloduck-scraper-intelligence.md
- **Developed by:** [Marielise](https://apify.com/marielise.dev) (community)
- **Categories:** AI, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 listing scrapeds

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

## ApolloDuck Scraper & Market Intelligence

Search ApolloDuck properly instead of clicking through categories by hand.

This actor scrapes public ApolloDuck listings and returns them as structured data. If you enable AI, it can also turn a plain-English request into filters, rank the results by relevance, and write a report for a buyer, broker, or seller.

It was built for ApolloDuck specifically, which matters because ApolloDuck is not just another yacht marketplace. It has sailing yachts and motorboats, but also narrowboats, barges, houseboats, inland craft, fishing boats, inflatables, and other categories that generic marine scrapers usually handle badly.

### Why use this actor

- Search ApolloDuck with either structured filters or a plain-English query
- Pull listing data into a clean dataset instead of working from inconsistent page HTML
- Rank results by how well they match your criteria
- Scrape detail pages for more useful specs, descriptions, seller information, and photos
- Generate a report when you want help comparing listings or thinking about the market

### What it is good for

- Buyers trying to narrow down live listings quickly
- Brokers who want a snapshot of inventory and pricing
- Sellers who want rough comparable asking-price context
- Researchers building ApolloDuck datasets without writing a custom scraper

Typical examples:

- "Used narrowboats in the UK under £80k"
- "Family sailing catamarans in Greece or Croatia under €250k"
- "Barges in France with detail pages and pricing data"
- "What does the current narrowboat market look like?"

### How it works

There are two ways to use it.

#### 1. Structured filters

Use this when you already know the filters you want.

```json
{
  "boatType": ["narrowboat", "barge"],
  "country": ["United Kingdom", "France"],
  "priceMax": 150000,
  "yearMin": 1995,
  "scrapeDetails": true,
  "maxResults": 50
}
````

#### 2. Natural-language search

Use this when you want the actor to interpret the request for you.

```json
{
  "query": "57ft narrowboat in the UK under £90k, good liveaboard layout",
  "mode": "buyer",
  "enableAI": true,
  "maxResults": 30
}
```

Seller-style example:

```json
{
  "query": "What is my 2012 Dutch barge in France worth?",
  "mode": "seller",
  "enableAI": true,
  "scrapeDetails": true,
  "maxResults": 40
}
```

### Main input fields

#### Search

- `query`: plain-English request
- `boatType`: array of boat types
- `country`: array of country names
- `brand`: optional manufacturer / builder filter
- `priceMin`, `priceMax`: price range
- `yearMin`, `yearMax`: build year range
- `lengthMin`, `lengthMax`: length range in metres
- `condition`: `new`, `used`, or `any`
- `sortBy`: result ordering
- `maxResults`: hard cap for the scrape

#### Intelligence

- `enableAI`: turns on query parsing and report generation
- `mode`: `buyer`, `seller`, or `broker`
- `aiApiKey`: optional user-supplied API key
- `aiBaseUrl`: optional OpenAI-compatible endpoint
- `aiModel`: optional model override

#### Scraping depth

- `scrapeDetails`: visits each detail page for richer specs and images

For broad inventory scans, leave `scrapeDetails` off.

For smaller, more important searches where equipment and detail matter, turn it on.

### Supported boat types

The schema currently supports:

`sailboat`, `sailing-yacht`, `motorboat`, `motor-yacht`, `catamaran`, `houseboat`, `fishing-boat`, `RIB`, `jet-ski`, `superyacht`, `trawler`, `flybridge`, `cabin-cruiser`, `center-console`, `bowrider`, `trimaran`, `classic-sailing-yacht`, `classic-power-boat`, `pontoon-boat`, `dinghy`, `narrowboat`, `barge`, `sport-boat`, `inflatable-boat`

These are mapped internally onto ApolloDuck's actual categories and subcategories.

### What comes back

Each run pushes one dataset item containing:

- `report`
- `query`
- `mode`
- `totalListings`
- `priceStats`
- `listings`
- `processingSeconds`

Each listing can include:

- title and URL
- original price and normalized EUR price
- boat type, brand, model
- year, length, beam
- location and country
- seller and seller type
- material and engine
- images
- relevance score
- matched and missing features
- detail-page data when `scrapeDetails` is enabled

### AI behavior and billing

`enableAI` controls the intelligence layer.

When AI is on, the actor can:

- parse a natural-language query into structured filters
- generate an AI report after scraping results

Current billing behavior is:

- `listing-scraped` is charged once per listing returned
- `report-generated` is charged only when a report is successfully generated using the actor's built-in AI key
- if the user supplies their own API key, the report is not charged
- if no report is generated, nothing is charged for the report
- if no listings are found, no report is generated

If you want raw scraping only, set `enableAI` to `false`.

### Practical usage advice

#### For buyers

Keep `maxResults` relatively low and turn `scrapeDetails` on when equipment or layout matters.

#### For brokers

Pull a wider result set first, then run more focused searches if needed.

#### For sellers

Do not over-constrain the price range. Comparable asking prices are more useful when the actor can see the wider market.

### Notes and limitations

- ApolloDuck is an asking-price marketplace, not a sold-prices database
- Price normalization uses static exchange rates in code, not live FX
- Detail scraping is slower because each listing page is opened individually
- Some listings are sparse, so the output quality depends on what ApolloDuck actually shows
- Sold or sale-agreed listings are excluded when that status is detectable

### In plain terms

If you want ApolloDuck data in a usable format, this actor will do that.

If you also want help interpreting the results, turn AI on and use the report mode that fits the job.

# Actor input Schema

## `query` (type: `string`):

Describe what you're looking for in plain language. Examples: "Family catamaran under €200k in the Mediterranean", "What's a 2018 Bavaria 46 worth?", "Beneteau sailboat market trends in France"

## `mode` (type: `string`):

How should the AI analyse the results?

## `enableAI` (type: `boolean`):

Enable AI-powered natural language search and market intelligence reports. When ON without your own API key, uses the actor's built-in AI (additional charge per report). When OFF, the actor only scrapes — no AI features.

## `aiApiKey` (type: `string`):

Bring your own OpenAI-compatible API key. When provided, AI features use your key at no extra charge. Leave empty to use the actor's built-in AI.

## `aiBaseUrl` (type: `string`):

API base URL for your provider. Examples: https://api.openai.com/v1 (OpenAI), https://api.groq.com/openai/v1 (Groq), https://api.together.xyz/v1 (Together)

## `aiModel` (type: `string`):

Model to use. Examples: gpt-4o (OpenAI), llama-3.1-70b-versatile (Groq), mistral-large-latest (Mistral)

## `boatType` (type: `array`):

Types of boats to search for. The AI query will set this automatically, but you can override it here.

## `country` (type: `array`):

Countries to search in (e.g., 'Germany', 'Croatia'). Leave empty for all.

## `priceMin` (type: `integer`):

Minimum price in EUR

## `priceMax` (type: `integer`):

Maximum price in EUR

## `yearMin` (type: `integer`):

Earliest year of manufacture

## `yearMax` (type: `integer`):

Latest year of manufacture

## `lengthMin` (type: `number`):

Minimum length in metres

## `lengthMax` (type: `number`):

Maximum length in metres

## `brand` (type: `array`):

Filter by manufacturer/brand (e.g., 'Beneteau', 'Bavaria'). Leave empty for all.

## `condition` (type: `string`):

Filter by boat condition

## `scrapeDetails` (type: `boolean`):

Visit each listing's detail page for full specs, equipment list, complete description, and all photos. Slower but much richer data. Recommended for smaller result sets (under 50).

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

Maximum number of listings to scrape. The AI may suggest a value based on your query.

## `sortBy` (type: `string`):

How to sort search results

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

Configure proxy settings. Default uses Apify's smart proxy selection.

## Actor input object example

```json
{
  "query": "40ft sailing catamaran under €200k in Croatia or Greece, good for family cruising",
  "mode": "buyer",
  "enableAI": true,
  "aiBaseUrl": "https://api.openai.com/v1",
  "aiModel": "gpt-4o",
  "boatType": [],
  "country": [],
  "brand": [],
  "condition": "any",
  "scrapeDetails": false,
  "maxResults": 100,
  "sortBy": "newest",
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `listingsOverview` (type: `string`):

Summary view of boat listings with key specs and prices

## `fullDetails` (type: `string`):

Complete boat listing data including all specs, seller info, and images

## `keyValueStore` (type: `string`):

Actor run key-value store for accessing run metadata

# 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 = {
    "query": "40ft sailing catamaran under €200k in Croatia or Greece, good for family cruising"
};

// Run the Actor and wait for it to finish
const run = await client.actor("marielise.dev/apolloduck-scraper-intelligence").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 = { "query": "40ft sailing catamaran under €200k in Croatia or Greece, good for family cruising" }

# Run the Actor and wait for it to finish
run = client.actor("marielise.dev/apolloduck-scraper-intelligence").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 '{
  "query": "40ft sailing catamaran under €200k in Croatia or Greece, good for family cruising"
}' |
apify call marielise.dev/apolloduck-scraper-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ApolloDuck Scraper & Market Intelligence",
        "description": "Scrape ApolloDuck listings with structured filters or natural-language AI search. Extract boats, barges, narrowboats, prices, specs, sellers, and photos, then generate buyer, seller, or broker-style market intelligence reports.",
        "version": "0.0",
        "x-build-id": "YFQ5CR9QFandsPfCe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/marielise.dev~apolloduck-scraper-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-marielise.dev-apolloduck-scraper-intelligence",
                "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/marielise.dev~apolloduck-scraper-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-marielise.dev-apolloduck-scraper-intelligence",
                "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/marielise.dev~apolloduck-scraper-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-marielise.dev-apolloduck-scraper-intelligence",
                "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": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Describe what you're looking for in plain language. Examples: \"Family catamaran under €200k in the Mediterranean\", \"What's a 2018 Bavaria 46 worth?\", \"Beneteau sailboat market trends in France\""
                    },
                    "mode": {
                        "title": "Intelligence Mode",
                        "enum": [
                            "buyer",
                            "broker",
                            "seller"
                        ],
                        "type": "string",
                        "description": "How should the AI analyse the results?",
                        "default": "buyer"
                    },
                    "enableAI": {
                        "title": "Enable AI Intelligence",
                        "type": "boolean",
                        "description": "Enable AI-powered natural language search and market intelligence reports. When ON without your own API key, uses the actor's built-in AI (additional charge per report). When OFF, the actor only scrapes — no AI features.",
                        "default": true
                    },
                    "aiApiKey": {
                        "title": "Your AI API Key (Optional)",
                        "type": "string",
                        "description": "Bring your own OpenAI-compatible API key. When provided, AI features use your key at no extra charge. Leave empty to use the actor's built-in AI."
                    },
                    "aiBaseUrl": {
                        "title": "AI Base URL",
                        "type": "string",
                        "description": "API base URL for your provider. Examples: https://api.openai.com/v1 (OpenAI), https://api.groq.com/openai/v1 (Groq), https://api.together.xyz/v1 (Together)",
                        "default": "https://api.openai.com/v1"
                    },
                    "aiModel": {
                        "title": "AI Model",
                        "type": "string",
                        "description": "Model to use. Examples: gpt-4o (OpenAI), llama-3.1-70b-versatile (Groq), mistral-large-latest (Mistral)",
                        "default": "gpt-4o"
                    },
                    "boatType": {
                        "title": "Boat Type",
                        "type": "array",
                        "description": "Types of boats to search for. The AI query will set this automatically, but you can override it here.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "sailboat",
                                "motorboat",
                                "catamaran",
                                "sailing-yacht",
                                "motor-yacht",
                                "houseboat",
                                "fishing-boat",
                                "RIB",
                                "jet-ski",
                                "superyacht",
                                "trawler",
                                "flybridge",
                                "cabin-cruiser",
                                "center-console",
                                "bowrider",
                                "trimaran",
                                "classic-sailing-yacht",
                                "classic-power-boat",
                                "pontoon-boat",
                                "dinghy",
                                "narrowboat",
                                "barge",
                                "sport-boat",
                                "inflatable-boat"
                            ]
                        },
                        "default": []
                    },
                    "country": {
                        "title": "Country",
                        "type": "array",
                        "description": "Countries to search in (e.g., 'Germany', 'Croatia'). Leave empty for all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "priceMin": {
                        "title": "Min Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in EUR"
                    },
                    "priceMax": {
                        "title": "Max Price (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in EUR"
                    },
                    "yearMin": {
                        "title": "Min Year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Earliest year of manufacture"
                    },
                    "yearMax": {
                        "title": "Max Year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Latest year of manufacture"
                    },
                    "lengthMin": {
                        "title": "Min Length (m)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Minimum length in metres"
                    },
                    "lengthMax": {
                        "title": "Max Length (m)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Maximum length in metres"
                    },
                    "brand": {
                        "title": "Brand",
                        "type": "array",
                        "description": "Filter by manufacturer/brand (e.g., 'Beneteau', 'Bavaria'). Leave empty for all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "new",
                            "used",
                            "any"
                        ],
                        "type": "string",
                        "description": "Filter by boat condition",
                        "default": "any"
                    },
                    "scrapeDetails": {
                        "title": "Scrape Detail Pages",
                        "type": "boolean",
                        "description": "Visit each listing's detail page for full specs, equipment list, complete description, and all photos. Slower but much richer data. Recommended for smaller result sets (under 50).",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape. The AI may suggest a value based on your query.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "price-asc",
                            "price-desc",
                            "newest",
                            "length-desc"
                        ],
                        "type": "string",
                        "description": "How to sort search results",
                        "default": "newest"
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxy settings. Default uses Apify's smart proxy selection.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```