# Blocket.se Scraper – Cars, Electronics & Marketplace Items (`logiover/blocket-se-scraper`) Actor

Blocket.se unofficial API alternative. Scrape Swedish classifieds and used-car listings without login; export prices, images and seller data to JSON/CSV.

- **URL**: https://apify.com/logiover/blocket-se-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** E-commerce, Business
- **Stats:** 29 total users, 7 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## 🇸🇪 Blocket.se Scraper — Sweden's Largest Classifieds Platform

Extract listings from **[Blocket.se](https://www.blocket.se)** — Sweden's #1 classified ads platform, founded in 1996 and used by millions of Swedes every month. Scrape **marketplace goods and vehicles** (cars, motorcycles, boats) across all Swedish regions — with prices, images, seller details, location coordinates and vehicle-specific attributes.

This scraper calls Blocket's official search API directly (`recommerce` for marketplace goods, `mobility` for vehicles) for fast, structured, complete data — no browser, no login.

---

### 🔍 What can you scrape?

Pick a category from the **Category** dropdown. Leave it empty to search across all listings.

| Category | Input value |
|----------|-------------|
| 🛍️ All listings | `` (empty) |
| 🚗 Cars | `car` |
| 🏍️ MC & Moped | `mc` |
| ⛵ Boats | `boat` |
| 📱 Electronics & Appliances | `0.93` |
| 🛋️ Furniture & Home | `0.78` |
| 👗 Fashion (Clothing, Cosmetics, Accessories) | `0.71` |
| ⚽ Sport & Leisure | `0.69` |
| 🎸 Hobby & Entertainment | `0.86` |
| 👶 Parents & Kids | `0.68` |
| 🐾 Pets & Accessories | `0.77` |
| 🖼️ Art & Antiques | `0.76` |
| 🌱 Garden & Renovation | `0.67` |
| 🔧 Vehicle Parts & Accessories | `0.90` |
| 💼 Business | `0.91` |

> `car`, `mc` and `boat` use Blocket's dedicated vehicle (mobility) API and return extra fields like make, model, year, mileage and fuel type.

---

### 🌍 Swedish regions

Filter by region using the **Region** dropdown. Leave empty to search all of Sweden.

| Region | Input value |
|--------|-------------|
| Hela Sverige (All Sweden) | `` (empty) |
| Stockholm | `0.300001` |
| Västra Götaland (Gothenburg) | `0.300014` |
| Skåne (Malmö) | `0.300012` |
| Uppsala | `0.300003` |
| Östergötland | `0.300005` |
| Södermanland | `0.300004` |
| Jönköping | `0.300006` |
| Kronoberg | `0.300007` |
| Kalmar | `0.300008` |
| Gotland | `0.300009` |
| Blekinge | `0.300010` |
| Värmland | `0.300013` |
| Västmanland | `0.300017` |
| Örebro | `0.300018` |
| Dalarna | `0.300019` |
| Gävleborg | `0.300020` |
| Västernorrland | `0.300021` |
| Jämtland | `0.300022` |
| Västerbotten | `0.300023` |
| Norrbotten | `0.300024` |

---

### 💡 Use cases

**Marketplace & E-commerce**
- Price monitoring and comparison for second-hand goods across Sweden
- Arbitrage opportunity detection between Blocket and other platforms
- Brand presence analysis — track which products sell and at what price
- Build price alert tools for specific items or categories
- AI training datasets with Swedish-language product listings

**Vehicles**
- Build Swedish used-car valuation tools with real market data
- Track Volvo, SAAB, BMW pricing trends by model, year and mileage
- Monitor dealer (Företag) vs private (Privat) seller price differences
- Competitive intelligence for Swedish car dealerships

---

### 📦 Output fields

#### Common fields (all categories)

| Field | Description | Example |
|-------|-------------|---------|
| `id` | Unique Blocket listing ID | `"23211366"` |
| `url` | Full listing URL | `"https://www.blocket.se/recommerce/forsale/item/23211366"` |
| `title` | Listing headline | `"iPhone 15 Pro 256GB Svart"` |
| `price` | Asking price in SEK | `"8 500 kr"` |
| `location` | City or town | `"Stockholm"` |
| `category` | Blocket search key | `"BAP_ALL"` |
| `sellerName` | Dealer or organisation name (if any) | `"Bilfirma AB"` |
| `sellerType` | `Privat` or `Företag` | `"Privat"` |
| `shipping` | `Kan skickas` if the item can be shipped | `"Kan skickas"` |
| `brand` | Product brand from listing attributes | `"Apple"` |
| `imageUrl` | Cover photo URL | `"https://img.blocket.se/..."` |
| `imageUrls` | All photo URLs, comma-separated | `"url1, url2, url3"` |
| `tradeType` | `Säljes` / `Bytes` / `Skänkes` | `"Säljes"` |
| `publishedAt` | ISO publication timestamp | `"2026-03-16T10:32:00.000Z"` |
| `lat` / `lng` | GPS coordinates of the listing | `"59.3293"` / `"18.0686"` |
| `scrapedAt` | ISO scrape timestamp | `"2026-05-14T09:42:46.272Z"` |

#### 🚗 Vehicle fields (car / mc / boat only)

| Field | Description | Example |
|-------|-------------|---------|
| `make` | Vehicle brand | `"Volvo"` |
| `model` | Vehicle model | `"V70"` |
| `modelSpec` | Full specification string | `"V70 D4 Momentum"` |
| `year` | Model year | `"2018"` |
| `mileage` | Odometer in mil (1 mil = 10 km) | `"8 500 mil"` |
| `fuel` | Fuel type | `"Bensin"` / `"Diesel"` / `"El"` |
| `gearbox` | Transmission | `"Automat"` / `"Manuell"` |
| `regno` | Swedish registration number (if listed) | `"ABC123"` |

---

### ⚙️ Input options

#### Search all of Sweden
```json
{
  "searchQuery": "iPhone",
  "category": "",
  "location": "",
  "maxResults": 100
}
````

#### Search cars in Stockholm

```json
{
  "searchQuery": "Volvo",
  "category": "car",
  "location": "0.300001",
  "maxResults": 100
}
```

#### All electronics in Gothenburg

```json
{
  "searchQuery": "",
  "category": "0.93",
  "location": "0.300014",
  "maxResults": 200
}
```

#### Unlimited — full category export

```json
{
  "searchQuery": "",
  "category": "car",
  "location": "",
  "maxResults": 0
}
```

***

### 📊 Sample output (vehicle)

```json
{
  "id": "23047162",
  "url": "https://www.blocket.se/mobility/item/23047162",
  "title": "Volvo V90 Cross Country",
  "price": "224 800 kr",
  "location": "Bromma",
  "category": "CAR_USED",
  "sellerType": "Företag",
  "make": "Volvo",
  "model": "V90",
  "modelSpec": "V90 Cross Country D4 AWD",
  "year": "2019",
  "mileage": "9 200 mil",
  "fuel": "Diesel",
  "gearbox": "Automat",
  "imageUrl": "https://img.blocket.se/...",
  "publishedAt": "2026-05-10T14:22:00.000Z",
  "lat": "59.3415",
  "lng": "17.9389",
  "scrapedAt": "2026-05-14T09:42:46.272Z"
}
```

***

### 💰 Pricing

Pay per result — you are only charged for listings actually saved to your dataset.

| Volume | Estimated cost |
|--------|---------------|
| 100 listings | ~$0.50 |
| 500 listings | ~$2.50 |
| 1,000 listings | ~$5.00 |
| 10,000 listings | ~$50.00 |

| Tier | Price per result |
|------|-----------------|
| Default | $0.005 |
| Bronze | $0.0045 |
| Silver | $0.004 |
| Gold | $0.0035 |

***

### ⚡ Performance

- **Direct API access** — calls Blocket's `recommerce` and `mobility` search APIs as JSON, no browser
- **Automatic pagination** — follows all pages up to `maxResults`
- **Deduplication** — each listing is saved exactly once
- **Apify Proxy** — requests routed through Apify's proxy pool by default

***

### ❓ FAQ

**How large is Blocket.se?**
Blocket.se is Sweden's largest and oldest classifieds platform, founded in 1996, with millions of monthly users and a constantly refreshed pool of listings across marketplace goods and vehicles.

**What language are the listings in?**
Swedish. All titles and attribute values appear in Swedish exactly as shown on blocket.se.

**What is "mil" in mileage?**
Swedish vehicles use "mil" (Swedish mile = 10 km) for odometer readings. So "8 500 mil" = 85,000 km.

**Can I filter by a specific car make or model?**
Yes — put the make/model in `searchQuery` (e.g. `"Volvo V70"`) and set `category` to `car`.

**Is scraping Blocket.se legal?**
This scraper collects publicly available listing data visible to any website visitor without login. Always use scraped data responsibly and in compliance with applicable laws in your jurisdiction.

#### Is this a Blocket.se API alternative?

Yes. Blocket has no public developer API, so this actor works as an unofficial Blocket.se API alternative — it queries Blocket's own search endpoints and returns structured JSON for marketplace goods and vehicles.

#### How do I export Blocket.se data to CSV or JSON?

Run the actor, then download the dataset from Apify in CSV, JSON, or Excel. Every listing — prices, images, seller details and vehicle attributes — is exported in one structured table.

#### Can I scrape Blocket.se without an API or login?

Yes. The scraper calls Blocket's public search API directly, so you get a complete Blocket.se data export with no login, no cookies and no browser session required.

### 📝 Changelog

#### 2026-06-15

- Reliability pass: re-verified end-to-end on live data with real-world inputs. Routine maintenance build.

#### 2026-06-07

- Docs: added coverage for Blocket.se API alternative usage, exporting Blocket listings to CSV/JSON, and scraping Blocket without an API or login.

#### 2026-06-05

- 🛡️ Reliability fix: results are no longer dropped by strict output validation — runs now complete cleanly even at high volume (thousands of results).
- ⚡ Stability & performance hardening; fresh rebuild.

#### 2026-06-04

- Verified live & refreshed build — reliability/maintenance pass.

# Actor input Schema

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

Keyword to search for on Blocket.se. Examples: 'iPhone 15', 'Volvo V70', 'cykel', 'soffa'. Leave empty to browse all listings in the selected category.

## `category` (type: `string`):

Limit results to a specific product category. Use 'car', 'mc', or 'boat' for vehicle searches (uses the mobility endpoint). Use numeric codes for marketplace categories. Leave empty to search across all listings.

## `location` (type: `string`):

Filter listings by Swedish region or county. Uses Blocket's internal region codes. Leave empty to search all of Sweden (Hela Sverige).

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

Maximum number of listings to scrape and save to the dataset. The scraper paginates automatically until this limit is reached. Set to 0 for unlimited results (use with caution on broad queries).

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

Apify proxy settings used for all requests to Blocket.se. Residential proxies are recommended for large-scale scraping to avoid blocks.

## Actor input object example

```json
{
  "searchQuery": "",
  "category": "",
  "location": "",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `id` (type: `string`):

Unique Blocket listing ID

## `url` (type: `string`):

Full listing URL on blocket.se

## `title` (type: `string`):

Listing headline

## `price` (type: `string`):

Asking price in SEK

## `location` (type: `string`):

City or town

## `category` (type: `string`):

Blocket search key / category

## `sellerName` (type: `string`):

Dealer or organisation name

## `sellerType` (type: `string`):

Privat or Företag

## `shipping` (type: `string`):

Kan skickas (shippable) or null

## `brand` (type: `string`):

Product brand from listing attributes

## `imageUrl` (type: `string`):

Cover photo URL

## `imageUrls` (type: `string`):

All photo URLs comma-separated

## `tradeType` (type: `string`):

Säljes / Bytes / Skänkes

## `publishedAt` (type: `string`):

ISO timestamp of publication

## `lat` (type: `string`):

GPS latitude

## `lng` (type: `string`):

GPS longitude

## `make` (type: `string`):

\[Vehicles] Brand e.g. Volvo, BMW

## `model` (type: `string`):

\[Vehicles] Model name

## `modelSpec` (type: `string`):

\[Vehicles] Full specification string

## `year` (type: `string`):

\[Vehicles] Model year

## `mileage` (type: `string`):

\[Vehicles] Odometer in mil (1 mil = 10 km)

## `fuel` (type: `string`):

\[Vehicles] Bensin / Diesel / El / Hybrid

## `gearbox` (type: `string`):

\[Vehicles] Automatisk / Manuell

## `regno` (type: `string`):

\[Vehicles] Swedish registration number

## `scrapedAt` (type: `string`):

ISO timestamp of scrape

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/blocket-se-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("logiover/blocket-se-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 '{}' |
apify call logiover/blocket-se-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Blocket.se Scraper – Cars, Electronics & Marketplace Items",
        "description": "Blocket.se unofficial API alternative. Scrape Swedish classifieds and used-car listings without login; export prices, images and seller data to JSON/CSV.",
        "version": "0.0",
        "x-build-id": "fIZC0evw1m9QBVH9W"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~blocket-se-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-blocket-se-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/logiover~blocket-se-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-blocket-se-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/logiover~blocket-se-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-blocket-se-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": "Keyword to search for on Blocket.se. Examples: 'iPhone 15', 'Volvo V70', 'cykel', 'soffa'. Leave empty to browse all listings in the selected category.",
                        "default": ""
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "car",
                            "mc",
                            "boat",
                            "0.93",
                            "0.78",
                            "0.71",
                            "0.69",
                            "0.86",
                            "0.68",
                            "0.77",
                            "0.76",
                            "0.67",
                            "0.90",
                            "0.91"
                        ],
                        "type": "string",
                        "description": "Limit results to a specific product category. Use 'car', 'mc', or 'boat' for vehicle searches (uses the mobility endpoint). Use numeric codes for marketplace categories. Leave empty to search across all listings.",
                        "default": ""
                    },
                    "location": {
                        "title": "Region",
                        "enum": [
                            "",
                            "0.300001",
                            "0.300014",
                            "0.300012",
                            "0.300003",
                            "0.300005",
                            "0.300004",
                            "0.300006",
                            "0.300007",
                            "0.300008",
                            "0.300009",
                            "0.300010",
                            "0.300013",
                            "0.300017",
                            "0.300018",
                            "0.300019",
                            "0.300020",
                            "0.300021",
                            "0.300022",
                            "0.300023",
                            "0.300024"
                        ],
                        "type": "string",
                        "description": "Filter listings by Swedish region or county. Uses Blocket's internal region codes. Leave empty to search all of Sweden (Hela Sverige).",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape and save to the dataset. The scraper paginates automatically until this limit is reached. Set to 0 for unlimited results (use with caution on broad queries).",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy settings used for all requests to Blocket.se. Residential proxies are recommended for large-scale scraping to avoid blocks.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
