# Dealabs Deals Scraper (`automation-lab/dealabs-deals-scraper`) Actor

Scrape public Dealabs deals for French ecommerce monitoring: prices, merchants, temperatures, comments, categories, images, and URLs.

- **URL**: https://apify.com/automation-lab/dealabs-deals-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

## Dealabs Deals Scraper

Scrape public Dealabs deal listings, category pages, and search pages for French ecommerce monitoring.

### What does Dealabs Deals Scraper do?

Dealabs Deals Scraper extracts structured deal data from public pages on `dealabs.com`.
It is designed for teams that need a repeatable feed of French community deals without manually checking the website.
The actor reads server-rendered Dealabs listing pages, parses the embedded deal payloads, and saves clean dataset rows.

It can collect:

- 🛒 Deal titles and public Dealabs URLs
- 💶 Prices, old prices, discounts, and shipping information
- 🏪 Merchant names and merchant hosts
- 🔥 Deal temperatures, hot flags, and Dealabs status flags
- 💬 Comment counts for community engagement monitoring
- 🏷️ Deal categories and category slugs
- 🖼️ Product image URLs when Dealabs exposes them
- 👤 Poster usernames and posted timestamps when visible

### Who is it for?

This actor is useful for ecommerce, retail, affiliate, and price-intelligence workflows focused on the French market.

Typical users include:

- 🧑‍💼 Affiliate managers tracking merchant mentions on Dealabs
- 🛍️ Ecommerce teams monitoring competitor promotions
- 📈 Price intelligence teams watching discount depth and community response
- 🧾 Voucher and coupon teams discovering active deal threads
- 📰 Deal publishers looking for public trends and high-temperature bargains
- 🧪 Analysts comparing Dealabs activity against HotUKDeals, MyDealz, or other Pepper-network sites

### Why use this actor?

Dealabs is one of the most important French community deal sources.
Manual monitoring is slow, and browser bookmarks do not produce structured data.
This actor gives you a repeatable dataset that can be exported, scheduled, filtered, or connected to other tools.

### Public data only

The actor only scrapes public Dealabs listing data visible without logging in.
It does not post, vote, message users, access private accounts, or bypass account-only pages.

### Supported source types

You can scrape several public source types:

- Category pages such as `https://www.dealabs.com/groupe/high-tech`
- Search pages such as `https://www.dealabs.com/search?q=iphone`
- The Dealabs homepage or other public listing URLs
- Category slugs such as `high-tech`, converted automatically to Dealabs group URLs
- Search keywords, converted automatically to Dealabs search URLs

### Data fields

| Field | Description |
| --- | --- |
| `dealId` | Dealabs thread id |
| `title` | Deal title |
| `price` | Current deal price when available |
| `oldPrice` | Previous / next-best price when Dealabs provides it |
| `discountPercentage` | Discount percentage from Dealabs metadata |
| `shippingPrice` | Shipping cost when available |
| `isFreeShipping` | Whether Dealabs marks shipping as free |
| `merchant` | Merchant display name |
| `merchantHost` | Merchant website host |
| `temperature` | Dealabs community temperature |
| `temperatureLevel` | Dealabs heat level label |
| `commentsCount` | Number of comments |
| `category` | Main category name |
| `categorySlug` | Main category slug |
| `status` | Dealabs status value |
| `isExpired` | Whether the deal is expired |
| `isHot` | Whether Dealabs marks it hot |
| `isNew` | Whether Dealabs marks it new |
| `dealType` | Dealabs type, such as Deal |
| `voucherCode` | Voucher code when present |
| `imageUrl` | Public product image URL |
| `dealUrl` | Public Dealabs deal URL |
| `shareUrl` | Dealabs share URL |
| `postedAt` | ISO timestamp when available |
| `postedTimestamp` | Raw Dealabs timestamp |
| `userName` | Poster username |
| `sourceUrl` | Source listing URL |
| `sourcePage` | Page number scraped |
| `scrapedAt` | Actor scrape timestamp |

### How much does it cost to scrape Dealabs deals?

The actor uses pay-per-event pricing.
The current configuration is:

- `$0.005` per run start
- BRONZE tier: `$0.0004` per saved deal item, equal to `$0.40 / 1,000 deals`
- Other Apify tiers receive the standard platform discounts shown in the Store pricing panel

Always check the Apify Store pricing panel for the live price before running large jobs.

### Quick start

1. Open the actor on Apify.
2. Add one or more Dealabs category or search URLs.
3. Set `Maximum deals` to a small value for your first run.
4. Run the actor.
5. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### Input example

```json
{
  "startUrls": [
    { "url": "https://www.dealabs.com/groupe/high-tech" },
    { "url": "https://www.dealabs.com/search?q=iphone" }
  ],
  "categorySlugs": ["jeux-video"],
  "searchQueries": ["ordinateur portable"],
  "maxItems": 50,
  "maxPagesPerSource": 2,
  "includeExpired": false
}
````

### Output example

```json
{
  "dealId": "3353594",
  "title": "TV 43\" Philips Ambilight 43PUS8450 - QLED, 4K UHD",
  "price": 269,
  "oldPrice": null,
  "discountPercentage": 0,
  "merchant": "PcComponentes",
  "temperature": 148.79,
  "commentsCount": 1,
  "category": "High-Tech",
  "isExpired": false,
  "dealUrl": "https://www.dealabs.com/bons-plans/example-3353594",
  "sourceUrl": "https://www.dealabs.com/groupe/high-tech",
  "sourcePage": 1
}
```

### Category scraping tips

Use Dealabs group URLs when you want a stable source.
Examples:

- `https://www.dealabs.com/groupe/high-tech`
- `https://www.dealabs.com/groupe/jeux-video`
- `https://www.dealabs.com/groupe/maison`

You can also enter just the slug in `categorySlugs`.

### Search scraping tips

Use `searchQueries` for products, brands, merchants, or product families.
For example:

- `iphone`
- `lenovo`
- `air fryer`
- `pc portable`

Search pages can change quickly as new community threads appear.

### Pagination and limits

The actor uses the `page` query parameter for Dealabs listing pagination.
`maxPagesPerSource` controls how many pages are requested for each URL, category, or search term.
`maxItems` is a global cap across all sources.

For first runs, keep the prefilled values small.
For recurring monitoring, increase limits gradually after checking output quality and cost.

### Expired deals

By default, expired deals are skipped when Dealabs marks them as expired.
Enable `includeExpired` if you need historical or competitive analysis that includes expired promotions.

### Scheduling

You can schedule this actor to run hourly, daily, or weekly on Apify.
A common setup is:

- Run every hour for high-priority keywords
- Run daily for broad category monitoring
- Send dataset exports to a webhook or integration

### Integrations

The dataset can be connected to:

- Google Sheets for merchandising reports
- Airtable for promotion tracking
- Slack or Discord alerts for hot deals
- BI tools for price and merchant trend analysis
- CRM or affiliate workflows for merchant discovery

### 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/dealabs-deals-scraper').call({
  startUrls: [{ url: 'https://www.dealabs.com/groupe/high-tech' }],
  maxItems: 25,
  maxPagesPerSource: 1
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/dealabs-deals-scraper').call(run_input={
    'searchQueries': ['iphone'],
    'maxItems': 25,
    'maxPagesPerSource': 1,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~dealabs-deals-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["iphone"],"maxItems":25,"maxPagesPerSource":1}'
```

### MCP usage

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

MCP URL:

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

Claude Code setup:

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

Claude Desktop JSON config example:

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

Example prompts:

- "Run Dealabs Deals Scraper for high-tech deals and summarize the hottest merchants."
- "Scrape Dealabs search results for iPhone and return deals above 100 degrees."
- "Monitor Dealabs for laptop promotions and export the dataset URL."

### Quality checks

After a run, check:

- Deal URLs open on Dealabs
- Merchant and price fields look reasonable
- `commentsCount` and `temperature` are numeric
- `sourceUrl` matches your input source
- `isExpired` matches your filtering expectation

### Troubleshooting: why did I get fewer deals than requested?

Dealabs may have fewer public items for a source than your `maxItems` value.
The actor also skips duplicate deal ids across sources and, by default, skips expired deals.
Increase `maxPagesPerSource` or add more sources if you need more rows.

### Troubleshooting: why are some price fields null?

Not every Dealabs thread exposes a current price, old price, or shipping price.
Null values mean the field was not present in the public listing metadata.

### Limitations

This first version focuses on public listing data.
It does not open every deal detail page, vote, log in, post comments, or scrape account-only content.
Detail-page expansion can be added later if buyers need longer descriptions or comment bodies.

### Legality

Only scrape data you are allowed to process.
Review Dealabs terms, robots guidance, and applicable laws for your use case.
Avoid collecting personal data beyond what is necessary for your legitimate workflow.

### FAQ

**Can this actor scrape private Dealabs account data?**

No. It is designed for public listing pages only and does not log in.

**Can I monitor multiple categories in one run?**

Yes. Add several `startUrls`, `categorySlugs`, or `searchQueries`; `maxItems` remains the global output cap.

### Related scrapers

You may also need:

- HotUKDeals-style deal monitoring actors from Automation Lab
- MyDealz / Pepper-network scrapers when available
- Ecommerce product scrapers for merchant-specific tracking
- Price monitoring actors for product-level analysis

### Changelog

#### 0.1

Initial Dealabs public listing scraper with category, search, pagination, and structured deal output.

# Actor input Schema

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

Dealabs listing URLs to scrape, such as category pages, search pages, or the home page.

## `categorySlugs` (type: `array`):

Optional Dealabs group slugs to scrape from /groupe/<slug>, for example high-tech or jeux-video.

## `searchQueries` (type: `array`):

Optional Dealabs search terms. Each term is scraped from /search?q=<term>.

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

Maximum number of deal records to save across all sources.

## `maxPagesPerSource` (type: `integer`):

How many paginated Dealabs listing pages to request for each source URL, category, or search query.

## `includeExpired` (type: `boolean`):

Keep expired Dealabs deals in the output when they appear in listings.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.dealabs.com/groupe/high-tech"
    },
    {
      "url": "https://www.dealabs.com/search?q=iphone"
    }
  ],
  "categorySlugs": [
    "high-tech"
  ],
  "searchQueries": [
    "iphone"
  ],
  "maxItems": 20,
  "maxPagesPerSource": 2,
  "includeExpired": false
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.dealabs.com/groupe/high-tech"
        },
        {
            "url": "https://www.dealabs.com/search?q=iphone"
        }
    ],
    "categorySlugs": [
        "high-tech"
    ],
    "searchQueries": [
        "iphone"
    ],
    "maxItems": 20,
    "maxPagesPerSource": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/dealabs-deals-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [
        { "url": "https://www.dealabs.com/groupe/high-tech" },
        { "url": "https://www.dealabs.com/search?q=iphone" },
    ],
    "categorySlugs": ["high-tech"],
    "searchQueries": ["iphone"],
    "maxItems": 20,
    "maxPagesPerSource": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/dealabs-deals-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.dealabs.com/groupe/high-tech"
    },
    {
      "url": "https://www.dealabs.com/search?q=iphone"
    }
  ],
  "categorySlugs": [
    "high-tech"
  ],
  "searchQueries": [
    "iphone"
  ],
  "maxItems": 20,
  "maxPagesPerSource": 2
}' |
apify call automation-lab/dealabs-deals-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dealabs Deals Scraper",
        "description": "Scrape public Dealabs deals for French ecommerce monitoring: prices, merchants, temperatures, comments, categories, images, and URLs.",
        "version": "0.1",
        "x-build-id": "jhIbpexMOpPtib3dn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~dealabs-deals-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-dealabs-deals-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~dealabs-deals-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-dealabs-deals-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~dealabs-deals-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-dealabs-deals-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Dealabs listing URLs to scrape, such as category pages, search pages, or the home page.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "categorySlugs": {
                        "title": "Category slugs",
                        "type": "array",
                        "description": "Optional Dealabs group slugs to scrape from /groupe/<slug>, for example high-tech or jeux-video.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Optional Dealabs search terms. Each term is scraped from /search?q=<term>.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum deals",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of deal records to save across all sources.",
                        "default": 20
                    },
                    "maxPagesPerSource": {
                        "title": "Maximum pages per source",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many paginated Dealabs listing pages to request for each source URL, category, or search query.",
                        "default": 3
                    },
                    "includeExpired": {
                        "title": "Include expired deals",
                        "type": "boolean",
                        "description": "Keep expired Dealabs deals in the output when they appear in listings.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
