# Drouot Auction Lots Scraper (`automation-lab/drouot-auction-lots-scraper`) Actor

Extract Drouot auction lots, estimates, bids, images, sale details, auction houses, contacts, dates, and locations from public Drouot sale pages.

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

## Drouot Auction Lots Scraper

Extract public Drouot auction lot records from sale catalogues, the homepage, auction listings, and other pages that expose sale links. The actor returns lot titles, descriptions, estimates, bids, images, auction-house contact fields, sale dates, currencies, locations, and canonical Drouot URLs.

Use it when you need repeatable Drouot market intelligence without manually opening each catalogue page.

### What does Drouot Auction Lots Scraper do?

Drouot Auction Lots Scraper loads public pages on `drouot.com`, discovers Drouot sale catalogues, and extracts the embedded auction lot data that Drouot renders into the page HTML.

It can process:

- 🎨 Drouot sale catalogue URLs such as `/en/v/...`
- 🗂️ Drouot category or landing URLs when they expose sale links in the page HTML
- 📅 Auction listing pages when they expose sale catalogue links
- 🏠 The Drouot homepage when you want to follow currently featured sales
- 🔎 Optional keyword filters over loaded lot titles, descriptions, and sale titles

### Who is it for?

This actor is useful for teams that monitor auction supply and pricing signals on Drouot:

- 🖼️ **Art dealers** tracking comparable works, estimates, and sale calendars
- 📈 **Auction analysts** building market datasets for categories, brands, artists, or houses
- 🧾 **Insurers and appraisers** checking comparable public auction estimates
- 🛍️ **Resale marketplaces** sourcing lots and monitoring upcoming inventory
- 🏛️ **Auction houses and consultants** benchmarking sale mix and public catalogue data
- 🤖 **Developers** feeding Drouot lots into CRM, BI, alerting, or valuation workflows

### Why use this actor?

Drouot pages include rich structured state for auction lots, but collecting it manually is slow. This actor turns public catalogues into a clean dataset with stable field names.

Key benefits:

- ✅ One dataset row per Drouot lot
- ✅ Estimates, current bids, hammer/result values when visible
- ✅ Sale and auction-house context on every row
- ✅ Public contact fields where Drouot exposes them
- ✅ Image URLs suitable for review workflows
- ✅ HTTP-first extraction without browser overhead for the MVP

### Data extracted

| Field | Description |
| --- | --- |
| `title` | Lot title inferred from the public Drouot lot description/title |
| `description` | Long lot description when enabled |
| `detailUrl` | Canonical Drouot lot or sale URL |
| `lotId` | Drouot lot identifier |
| `lotNumber` | Lot number within the sale |
| `saleTitle` | Sale or catalogue title |
| `auctionHouse` | Public auction-house name |
| `auctionHouseEmail` | Public contact email when visible |
| `auctionHousePhone` | Public contact phone when visible |
| `location` | Public sale/auction-house location |
| `saleDate` | Sale timestamp converted to ISO date |
| `currency` | Currency shown by Drouot |
| `lowEstimate` | Low estimate |
| `highEstimate` | High estimate |
| `currentBid` | Current bid when visible |
| `nextBid` | Next bid when visible |
| `hammerPrice` | Result/hammer price when visible |
| `imageUrls` | Public Drouot CDN image URLs |

### How much does it cost to scrape Drouot auction lots?

This actor uses pay-per-event pricing:

- A small one-time **Start** charge per run
- A per-lot **Auction lot saved** charge for every dataset item produced

Final tiered pricing is set from measured Apify cloud cost before publication. Keep `maxItems` small for first tests, then raise it for production monitoring once you confirm the target sale pages contain the lots you need.

### How to scrape Drouot lots

1. Open a Drouot sale page, search page, category page, or auction listing.
2. Copy the URL into `startUrls`.
3. Set `maxItems` to the number of lots you need.
4. Optionally set `query` to filter loaded sale lots by a keyword such as `gold`, `watch`, `painting`, or an artist name; Drouot search URLs can also include `?query=...` or `?q=...`.
5. Run the actor.
6. Download the dataset as JSON, CSV, Excel, XML, or via the Apify API.

### Input options

#### `startUrls`

Drouot URLs to process. Sale URLs (`/en/v/...`) are scraped directly when Drouot embeds public lot data. Search URLs (`/en/search?query=gold` or `/en/search?q=gold`) use Drouot's public lot-search data. Homepage, listing, and category-style pages are scanned for sale links when those links are present in the page HTML, and then the actor opens those sale catalogues.

#### `query`

Optional keyword filter applied after each sale page is loaded. It checks lot title, lot description, and sale title. For Drouot search URLs, this value is used as the search keyword when the URL itself does not include `q` or `query`.

#### `maxItems`

Maximum number of lot records to save.

#### `followSaleLinks`

Enable this for category, homepage, and auction-listing URLs. Disable it only when you provide direct sale catalogue URLs.

#### `maxSales`

Maximum number of sale catalogue pages to open from a listing page.

#### `includeDescription`

Disable this if you want smaller output rows and only need summary metadata.

### Example input: one Drouot sale

```json
{
  "startUrls": [
    { "url": "https://drouot.com/en/v/182016-fine-jewellery-luxury-fashion-and-handbags" }
  ],
  "maxItems": 50,
  "includeDescription": true
}
````

### Example input: homepage sale discovery

```json
{
  "startUrls": [
    { "url": "https://drouot.com/en/" }
  ],
  "followSaleLinks": true,
  "maxSales": 3,
  "maxItems": 100
}
```

### Example input: filtered lots

```json
{
  "startUrls": [
    { "url": "https://drouot.com/en/search?query=gold" }
  ],
  "query": "gold",
  "maxItems": 25
}
```

### Example output

```json
{
  "sourceUrl": "https://drouot.com/en/v/182016-fine-jewellery-luxury-fashion-and-handbags",
  "detailUrl": "https://drouot.com/en/l/34292432-a-swiss-18ct-gold-and-enamel-full-hunter-fob-watch",
  "lotId": 34292432,
  "lotNumber": "1",
  "title": "A SWISS 18CT GOLD AND ENAMEL FULL HUNTER FOB WATCH",
  "saleTitle": "Fine Jewellery, Luxury Fashion and Handbags",
  "auctionHouse": "Azca Auctions",
  "currency": "GBP",
  "lowEstimate": 1800,
  "highEstimate": 2000,
  "currentBid": 0,
  "imageUrls": ["https://cdn.drouot.com/d/image/lot?size=fullHD&path=2877/182016/..."],
  "scrapedAt": "2026-07-05T00:00:00.000Z"
}
```

### Tips for best results

- Use direct sale catalogue URLs when possible.
- Use category pages only when you want the actor to discover sale catalogues.
- Keep `maxSales` low for focused monitoring.
- Use `query` for buyer-specific alerts, but remember it filters after sale pages are loaded.
- Increase `maxItems` only after a small test confirms the sale page contains relevant lots.

### Integrations

Common workflows include:

- 📊 Push Drouot lots to Google Sheets or Airtable for analyst review
- 🔔 Trigger alerts when a keyword appears in new Drouot lots
- 🧮 Feed estimate ranges into valuation models
- 🧾 Archive auction-house contact and sale information for due diligence
- 🧱 Combine with other auction scrapers in a data warehouse

### 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/drouot-auction-lots-scraper').call({
  startUrls: [{ url: 'https://drouot.com/en/v/182016-fine-jewellery-luxury-fashion-and-handbags' }],
  maxItems: 25,
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("automation-lab/drouot-auction-lots-scraper").call(run_input={
    "startUrls": [{"url": "https://drouot.com/en/v/182016-fine-jewellery-luxury-fashion-and-handbags"}],
    "maxItems": 25,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~drouot-auction-lots-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://drouot.com/en/v/182016-fine-jewellery-luxury-fashion-and-handbags"}],"maxItems":25}'
```

### MCP: use Drouot lots from AI tools

You can connect this actor to Apify MCP and ask Claude or another MCP client to run Drouot monitoring tasks.

Add the actor to Claude Code:

```bash
claude mcp add apify-drouot-auctions https://mcp.apify.com?tools=automation-lab/drouot-auction-lots-scraper
```

Claude Desktop MCP server configuration:

```json
{
  "mcpServers": {
    "apify-drouot-auctions": {
      "url": "https://mcp.apify.com?tools=automation-lab/drouot-auction-lots-scraper"
    }
  }
}
```

Direct MCP URL pattern:

```text
https://mcp.apify.com?tools=automation-lab/drouot-auction-lots-scraper
```

Example prompts:

- "Scrape the first 50 lots from this Drouot sale and summarize estimate ranges."
- "Find Drouot lots mentioning gold in this sale catalogue."
- "Extract auction-house contact details and sale dates from these Drouot catalogues."

### Legality and responsible use

This actor extracts public information from Drouot pages provided by the user. You are responsible for using the data lawfully and respecting Drouot terms, privacy rules, intellectual-property rights, and any contractual obligations that apply to your workflow.

Do not use the actor for spam, abusive automation, or collection of non-public information.

### Limitations

- Drouot may change its frontend state format.
- Some pages may expose fewer fields than others.
- Search route discovery is not part of the v0.1 MVP; provide sale/category/listing URLs.
- Hammer prices only appear when Drouot exposes result data in the public page state.
- Very large category crawls should be split into focused runs.

### Troubleshooting

#### No sale URLs found

Provide direct `/en/v/...` sale catalogue URLs or enable `followSaleLinks` for category/listing pages.

#### Fewer lots than expected

The sale may have multiple pages, hidden lots, or a keyword filter that excludes records. Remove `query` and retry a small test.

#### Missing estimates or bids

Drouot does not expose every price field for every sale state. Check whether the same values are visible publicly in the browser.

### Related scrapers

Related Automation Labs actors will be linked here after portfolio review. Useful neighboring categories include auction monitoring, art-market analysis, marketplace listing extraction, and lead/contact enrichment.

### FAQ

#### Can I scrape all Drouot categories?

Yes, but start with focused category URLs and conservative `maxSales` / `maxItems` limits.

#### Does it require a Drouot account?

No. The actor targets public Drouot pages and does not log in.

#### Does it use a browser?

No. The MVP uses HTTP extraction because sale pages include the necessary Svelte-rendered state in initial HTML.

#### Can I filter by artist or brand?

Use the `query` field. It filters public lot text after the sale page is loaded.

### Changelog

- `0.1` Initial implementation for Drouot public sale catalogue lot extraction.

# Actor input Schema

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

Drouot sale URLs (/en/v/...), search URLs (/en/search?...), category URLs (/en/c/...), auction listing URLs, or the homepage. Sale URLs produce lot records directly; search URLs use Drouot's public lot-search data.

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

Optional case-insensitive keyword filter applied to lot titles, descriptions, and sale titles after each Drouot sale page is loaded.

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

Maximum number of auction lot records to save.

## `followSaleLinks` (type: `boolean`):

When enabled, category/home/auction-listing pages are scanned for Drouot sale links and those sale pages are scraped for lots.

## `maxSales` (type: `integer`):

Maximum number of sale/catalog pages to open from listing or category pages.

## `includeDescription` (type: `boolean`):

Include long public lot descriptions in output records.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://drouot.com/en/search?query=gold"
    }
  ],
  "query": "gold",
  "maxItems": 20,
  "followSaleLinks": true,
  "maxSales": 3,
  "includeDescription": true
}
```

# 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://drouot.com/en/search?query=gold"
        }
    ],
    "query": "gold",
    "maxItems": 20,
    "followSaleLinks": true,
    "maxSales": 3,
    "includeDescription": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/drouot-auction-lots-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://drouot.com/en/search?query=gold" }],
    "query": "gold",
    "maxItems": 20,
    "followSaleLinks": True,
    "maxSales": 3,
    "includeDescription": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/drouot-auction-lots-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://drouot.com/en/search?query=gold"
    }
  ],
  "query": "gold",
  "maxItems": 20,
  "followSaleLinks": true,
  "maxSales": 3,
  "includeDescription": true
}' |
apify call automation-lab/drouot-auction-lots-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Drouot Auction Lots Scraper",
        "description": "Extract Drouot auction lots, estimates, bids, images, sale details, auction houses, contacts, dates, and locations from public Drouot sale pages.",
        "version": "0.1",
        "x-build-id": "H7tuZUZtDYXqGPuFW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~drouot-auction-lots-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-drouot-auction-lots-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~drouot-auction-lots-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-drouot-auction-lots-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~drouot-auction-lots-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-drouot-auction-lots-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Drouot URLs",
                        "type": "array",
                        "description": "Drouot sale URLs (/en/v/...), search URLs (/en/search?...), category URLs (/en/c/...), auction listing URLs, or the homepage. Sale URLs produce lot records directly; search URLs use Drouot's public lot-search data.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "query": {
                        "title": "Keyword filter",
                        "type": "string",
                        "description": "Optional case-insensitive keyword filter applied to lot titles, descriptions, and sale titles after each Drouot sale page is loaded."
                    },
                    "maxItems": {
                        "title": "Maximum lots",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of auction lot records to save.",
                        "default": 20
                    },
                    "followSaleLinks": {
                        "title": "Follow sale links",
                        "type": "boolean",
                        "description": "When enabled, category/home/auction-listing pages are scanned for Drouot sale links and those sale pages are scraped for lots.",
                        "default": true
                    },
                    "maxSales": {
                        "title": "Maximum sale pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of sale/catalog pages to open from listing or category pages.",
                        "default": 5
                    },
                    "includeDescription": {
                        "title": "Include descriptions",
                        "type": "boolean",
                        "description": "Include long public lot descriptions in output records.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```