# Byggmax Scraper — Swedish Building Materials & Timber (`studio-amba/byggmax-scraper`) Actor

Scrape products from Byggmax.se — Sweden's go-to chain for affordable building materials, timber, and renovation supplies.

- **URL**: https://apify.com/studio-amba/byggmax-scraper.md
- **Developed by:** [Jelle Desramaults](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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.

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

## Byggmax Scraper

Extract product data, prices, stock status, and specifications from byggmax.se -- Sweden's leading discount building materials chain. Covers timber, decking, insulation, screws, tools, paint, and everything else Swedish builders and renovators need.

### What is Byggmax Scraper?

Byggmax is Sweden's largest budget-focused building materials retailer. They operate a stripped-down, no-frills model: limited service, warehouse-style stores, and some of the lowest prices on construction supplies in Scandinavia. Their online catalog lists thousands of products from structural timber and insulation to screws, paint, and garden decking.

This scraper gives you structured access to Byggmax's full product range. Here is how people use it:

- **Nordic building cost benchmarking** -- Compare Swedish construction material prices against Finnish (K-Rauta), Norwegian, German (Hagebau, Bauhaus), and French (Brico Depot) equivalents. Byggmax often sets the floor price in Scandinavia
- **Timber and decking price tracking** -- Byggmax is the go-to source for trall (decking), virke (timber), and other wood products in Sweden. Track seasonal pricing on these high-volume categories
- **Renovation project costing** -- Extract pricing for complete renovation bills of materials: insulation, gypsum boards, screws, paint, flooring -- all in one scrape
- **Swedish retail competitor intelligence** -- Monitor how Byggmax positions against Bauhaus Sweden, K-Rauta, and Jula on overlapping product categories
- **Supplier and brand analysis** -- Map which brands supply the Swedish budget construction market and at what retail price points

### What data does Byggmax Scraper extract?

Each product includes the following fields when available:

- 🏷️ **Product name** -- Full product title in Swedish
- 🏢 **Brand** -- Manufacturer name
- 💰 **Price** -- Current price in SEK (Swedish kronor)
- 🔖 **Original price** -- Pre-sale price for discounted items
- 🆔 **Product ID** -- Byggmax internal product identifier
- 📦 **In stock** -- Availability indicator
- ⭐ **Rating** -- Customer rating when available
- 💬 **Review count** -- Number of reviews
- 🖼️ **Image URL** -- Main product image
- 🖼️ **Image URLs** -- Full product gallery (detail mode)
- 📝 **Description** -- Product description (detail mode)
- 🔧 **Specs** -- Technical specifications from product tables (detail mode)
- 📂 **Category** -- Full breadcrumb path (e.g., "Bygg > Skruv & Spik")

### How to scrape Byggmax

#### Search by keyword

```json
{
    "searchQuery": "trall",
    "maxResults": 100
}
````

Good Swedish search terms: `"trall"` (decking), `"skruv"` (screws), `"isolering"` (insulation), `"gips"` (gypsum board), `"virke"` (timber), `"puts"` (plaster), `"takpapp"` (roofing felt), `"color"` (paint).

#### Scrape a category

```json
{
    "categoryUrl": "https://www.byggmax.se/hus-och-bygg/virke/trall",
    "maxResults": 500
}
```

#### Quick listing vs. full detail mode

By default, the scraper extracts data from listing cards only -- fast but limited to name, price, image, and stock status. Set `scrapeDetails: true` to visit each product page for full descriptions, spec tables, and all images.

```json
{
    "searchQuery": "isolering",
    "maxResults": 50,
    "scrapeDetails": true
}
```

#### Input reference

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | String | Swedish keyword (default: `"skruv"`) |
| `categoryUrl` | String | Byggmax.se category URL or path |
| `maxResults` | Integer | Product limit (default: 100, max: 50,000) |
| `scrapeDetails` | Boolean | Visit product pages for full data (default: false) |
| `proxyConfiguration` | Object | Proxy settings (usually not needed for Byggmax) |

**Tip:** Byggmax is relatively open to scraping. Proxies are usually not needed for moderate volumes. The scraper handles Swedish price formats (`"1 234:-"` and `"1 234,50 kr"`) automatically.

### Output

```json
[
    {
        "name": "Tryckimpregnerad trall 28x120 mm",
        "brand": "Byggmax",
        "price": 49,
        "currency": "SEK",
        "originalPrice": 65,
        "productId": "52890",
        "inStock": true,
        "imageUrl": "https://www.byggmax.se/media/products/trall-28x120.jpg",
        "url": "https://www.byggmax.se/produkt/tryckimpregnerad-trall-28x120/52890",
        "scrapedAt": "2026-04-03T11:00:00.000Z"
    },
    {
        "name": "Gipsskruv fosfaterad 3,5x35 mm 1000-pack",
        "brand": "Essve",
        "price": 169,
        "currency": "SEK",
        "inStock": true,
        "imageUrl": "https://www.byggmax.se/media/products/gipsskruv-3-5x35.jpg",
        "description": "Fosfatbehandlad gipsskruv for montering av gipsskivor pa stareglar och trareglar. Fingangsgang.",
        "specs": {
            "Dimension": "3,5x35 mm",
            "Antal": "1000 st",
            "Material": "Stal, fosfaterad",
            "Anvandning": "Gipsskivor pa tra/stalregel"
        },
        "category": "Bygg > Skruv & Spik > Gipsskruv",
        "categories": ["Bygg", "Skruv & Spik", "Gipsskruv"],
        "url": "https://www.byggmax.se/produkt/gipsskruv-fosfaterad-3-5x35-1000/53412",
        "scrapedAt": "2026-04-03T11:00:12.000Z"
    },
    {
        "name": "Mineralull Paroc eXtra 195 mm 560x1170",
        "brand": "Paroc",
        "price": 399,
        "currency": "SEK",
        "originalPrice": 499,
        "inStock": true,
        "rating": 4.6,
        "reviewCount": 42,
        "imageUrl": "https://www.byggmax.se/media/products/paroc-extra-195.jpg",
        "description": "Universalisolering for vaggar, tak och golv. Lambda 0,036. Mjuk och latthanterlig. Paket om 3,28 m2.",
        "specs": {
            "Tjocklek": "195 mm",
            "Storlek": "560x1170 mm",
            "Lambdavarde": "0,036 W/mK",
            "Tacker per paket": "3,28 m2"
        },
        "category": "Bygg > Isolering > Mineralull",
        "categories": ["Bygg", "Isolering", "Mineralull"],
        "url": "https://www.byggmax.se/produkt/paroc-extra-195mm/48765",
        "scrapedAt": "2026-04-03T11:00:25.000Z"
    }
]
```

Export in **JSON**, **CSV**, **Excel**, **XML**, or **RSS**.

### How much does it cost?

Byggmax Scraper uses CheerioCrawler -- lightweight HTTP requests with no browser overhead.

| Scenario | Mode | Products | Estimated cost |
|----------|------|----------|----------------|
| Quick search | Listing | 100 | ~$0.02 |
| Category scan | Listing | 500 | ~$0.08 |
| Full product data | Detail | 200 | ~$0.10 |
| Large catalog crawl | Detail | 2,000 | ~$1.00 |

Listing-only mode is roughly twice as fast and half the cost of detail mode since it skips individual product page visits. The free Apify tier handles most monitoring needs.

### Can I integrate?

Feed Byggmax data into your workflow:

- **Webhooks** -- Trigger downstream actions on run completion
- **Google Sheets** -- Auto-sync prices to shared spreadsheets
- **Slack / Microsoft Teams** -- Price drop alerts for tracked products
- **Zapier / Make** -- Connect to 5,000+ apps
- **Amazon S3 / Google Cloud** -- Cloud bucket storage
- **PostgreSQL / MySQL** -- Database ingestion
- **API** -- Full programmatic access

### Can I use it as an API?

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/byggmax-scraper").call(run_input={
    "searchQuery": "trall",
    "maxResults": 100,
    "scrapeDetails": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['name']} - {item['price']} SEK")
```

#### JavaScript

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

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/byggmax-scraper").call({
    searchQuery: "trall",
    maxResults: 100,
    scrapeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => console.log(`${item.name} - ${item.price} SEK`));
```

### FAQ

**Why scrape Byggmax specifically?**
Byggmax is Sweden's price leader for building materials. If you are benchmarking Nordic construction costs or tracking timber prices, Byggmax represents the budget floor in the Swedish market. Their data is essential for any cross-border building material comparison.

**What is the difference between listing and detail mode?**
Listing mode (`scrapeDetails: false`) extracts basic data from product cards: name, price, image, stock status. Detail mode (`scrapeDetails: true`) visits each product page to additionally capture full descriptions, spec tables, all images, breadcrumb categories, and JSON-LD structured data. Listing mode is faster and cheaper; detail mode gives you complete product information.

**Are prices in SEK including VAT?**
Yes, all Byggmax prices include Swedish moms (VAT) at 25%. This is the standard consumer price.

**Can I track timber prices over time?**
Absolutely. Schedule the scraper to run weekly or daily with a category URL for timber (`/hus-och-bygg/virke/`). Each run creates a new dataset, giving you a price history over time.

**What about per-meter or per-pack pricing?**
Byggmax lists some products with per-meter (loppmeter) or per-pack pricing. The price field reflects whatever the site displays. Check the product name or description for unit details.

**How do Byggmax prices compare to other Nordic retailers?**
Byggmax typically offers 10-30% lower prices than K-Rauta (Finland) or Jula on overlapping product categories. Combine this scraper with our K-Rauta and Jula scrapers to quantify these differences.

### Limitations

- All data is in Swedish from byggmax.se
- Listing-only mode provides fewer fields (no description, specs, or categories)
- Some custom-order or "Kontakta oss" (contact us) products show a price of 0
- The scraper follows pagination automatically using Swedish-language link detection ("Nasta", "Visa fler")
- Proxy is usually not needed but may help for very large runs (5,000+ products)

### Other DIY & hardware scrapers

Build a complete Nordic and European building material price database:

- [Gamma Scraper](https://apify.com/studio-amba/gamma-scraper) -- Netherlands
- [Leroy Merlin Scraper](https://apify.com/studio-amba/leroymerlin-scraper) -- France
- [Brico Scraper](https://apify.com/studio-amba/brico-scraper) -- Belgium
- [Praxis Scraper](https://apify.com/studio-amba/praxis-scraper) -- Netherlands
- [OBI Scraper](https://apify.com/studio-amba/obi-scraper) -- Germany
- [Hornbach Scraper](https://apify.com/studio-amba/hornbach-scraper) -- Germany/Europe
- [Bauhaus Scraper](https://apify.com/studio-amba/bauhaus-scraper) -- Germany/Europe
- [Castorama Scraper](https://apify.com/studio-amba/castorama-scraper) -- France/Poland
- [Hubo Scraper](https://apify.com/studio-amba/hubo-scraper) -- Belgium/Netherlands
- [Toom Scraper](https://apify.com/studio-amba/toom-scraper) -- Germany
- [Hagebau Scraper](https://apify.com/studio-amba/hagebau-scraper) -- Germany
- [Globus Baumarkt Scraper](https://apify.com/studio-amba/globus-baumarkt-scraper) -- Germany
- [Bricorama Scraper](https://apify.com/studio-amba/bricorama-scraper) -- France
- [Brico Depot Scraper](https://apify.com/studio-amba/bricodepot-scraper) -- France
- [Bricomarche Scraper](https://apify.com/studio-amba/bricomarche-scraper) -- France
- [Clas Ohlson Scraper](https://apify.com/studio-amba/clasohlson-scraper) -- Scandinavia
- [Jula Scraper](https://apify.com/studio-amba/jula-scraper) -- Sweden
- [K-Rauta Scraper](https://apify.com/studio-amba/krauta-scraper) -- Finland

### Your feedback

We maintain this scraper actively. If you find issues, missing data, or want new features, let us know through the actor's Apify Store page or the community forum. Builder feedback makes these tools better for everyone.

# Actor input Schema

## `searchQuery` (type: `string`):

Search for products by keyword (e.g., 'skruv', 'trall', 'isolering'). Uses Byggmax search API.

## `categoryUrl` (type: `string`):

A Byggmax category URL or path to scrape. Example: https://www.byggmax.se/hus-och-bygg/virke/trall or just 'hus-och-bygg/virke/trall'. If empty and no search query, scrapes all products.

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

Maximum number of products to return.

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

Proxy settings. Usually not needed for Byggmax.

## Actor input object example

```json
{
  "searchQuery": "skruv",
  "maxResults": 100
}
```

# 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 = {
    "searchQuery": "skruv"
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/byggmax-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 = { "searchQuery": "skruv" }

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/byggmax-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 '{
  "searchQuery": "skruv"
}' |
apify call studio-amba/byggmax-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Byggmax Scraper — Swedish Building Materials & Timber",
        "description": "Scrape products from Byggmax.se — Sweden's go-to chain for affordable building materials, timber, and renovation supplies.",
        "version": "0.1",
        "x-build-id": "1XYksPhMAMEDaCvg9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~byggmax-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-byggmax-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/studio-amba~byggmax-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-byggmax-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/studio-amba~byggmax-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-byggmax-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by keyword (e.g., 'skruv', 'trall', 'isolering'). Uses Byggmax search API."
                    },
                    "categoryUrl": {
                        "title": "Category URL or Path",
                        "type": "string",
                        "description": "A Byggmax category URL or path to scrape. Example: https://www.byggmax.se/hus-och-bygg/virke/trall or just 'hus-och-bygg/virke/trall'. If empty and no search query, scrapes all products."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Usually not needed for Byggmax."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
