# Hemnet Property Scraper - Sweden Listings Data (`memo23/hemnet-property-scraper`) Actor

Scrape Swedish property listings from Hemnet.se by location keyword or by pasting results/property URLs. One row per property: asking price, monthly fee, rooms, living area, address, GPS coordinates, housing form, broker, labels and images. Optional detail-page enrichment. Export JSON, CSV or Excel.

- **URL**: https://apify.com/memo23/hemnet-property-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Real estate, AI, Agents
- **Stats:** 21 total users, 20 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 properties

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

## Hemnet Property Scraper

Turn any [Hemnet](https://www.hemnet.se) search into clean, structured property data. Search **for-sale listings by location**, paste a **results/search URL** you built on the site, or paste **individual property URLs** — and get one flat row per property with asking price, monthly fee, rooms, living area, street address, GPS coordinates, housing form, broker, labels and images. Flip on detail mode to add the full description, construction year and tenure.

Built for Swedish real-estate research, price monitoring, lead generation for brokers, and market datasets across all of Hemnet's for-sale inventory.

#### How it works

![How the Hemnet Property Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-hemnet.png)

#### ✨ Why use this scraper?

- **Rich rows out of the box** — ~40 fields per property straight from the results pages: asking price (raw + parsed number), monthly fee, price per m², rooms, living area, street address, location, latitude/longitude, housing form, new-construction flag, broker name + agency, status labels, description snippet and image URLs.
- **Three ways in** — location keyword, a results/search URL you built on hemnet.se (with all your filters), or direct property URLs. Mix them in one run.
- **Beats Hemnet's block** — Hemnet serves datacenter scrapers a Cloudflare "Just a moment…" challenge; this actor routes every request through Swedish residential IPs with a real browser fingerprint, so you get the real page.
- **Full detail on demand** — turn on *Scrape property detail pages* (or paste a property URL) to add the full listing description, construction year and tenure.
- **Coordinates included** — every row carries `latitude`/`longitude`, ready to plot on a map or join to geodata.
- **No brittle DOM scraping** — reads Hemnet's embedded JSON (Next.js/Apollo state), so the output stays stable when the page layout changes.
- **JSON, CSV, Excel or API** — pipe straight into your sheet, BI tool or pipeline. Billed per property.

#### 🎯 Use cases

| You are a… | Use it to… |
|---|---|
| Real-estate analyst | Track asking prices, price/m² and fees across areas and property types |
| Investor / buyer | Build a live feed of new listings in your target locations and price band |
| Broker / agency | Monitor competitor listings, pricing and inventory in your market |
| Data / app builder | Seed a Swedish property dataset with structured, geocoded listing rows |
| Journalist / researcher | Measure supply, new-construction share and price distribution by region |

#### 📥 Supported inputs

| Input | Example | What it does |
|---|---|---|
| Location keyword | `Stockholm`, `Göteborg`, `Malmö` | Resolves the location and paginates its newest for-sale listings |
| Results / search URL | `https://www.hemnet.se/bostader?location_ids[]=17744` | Paginates exactly that search (keeps all your filters) |
| Property URL | `https://www.hemnet.se/bostad/{slug}` | Scrapes that single property in full detail |

**Not supported:** account-only data, saved searches, contact/message flows, and anything behind a Hemnet login. The actor reads only public for-sale results and property pages.

> **Tip for precise filters:** build your search on hemnet.se (price, rooms, housing form, area, etc.), then copy the URL from your browser and paste it under *Results / search URLs*. Every filter in the URL is honoured, and pagination is automatic.

#### ⚙️ How it works

1. **You provide** location keywords, results URLs and/or property URLs.
2. The actor **classifies** each input into a results page or a property page.
3. Results pages are **paginated** (`?page=N`, 50 properties/page) up to your limits, through Swedish residential proxies with automatic retry on Cloudflare challenges.
4. Each property is parsed from Hemnet's **embedded JSON** into a flat row. With *Scrape property detail pages* on, each property's detail page is fetched to add the full description, construction year and tenure.
5. Rows are **de-duplicated** by property ID and pushed to the dataset — one paid `property` event each.

#### 🔧 Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | array | `["Stockholm"]` | Location keywords to search for-sale listings |
| `startUrls` | array | `[]` | Hemnet results URLs and/or property URLs (auto-classified) |
| `scrapeDetails` | boolean | `false` | Also fetch each property's detail page (full description, construction year, tenure) |
| `maxItems` | integer | `1000` | Hard cap on rows for the whole run |
| `maxItemsPerSearch` | integer | `1000` | Cap per location / results URL |
| `maxConcurrency` | integer | `6` | Parallel requests (keep 4–8 — Hemnet is Cloudflare-protected) |
| `maxRequestRetries` | integer | `20` | Retry budget per request (rotates to a fresh Swedish IP each time) |
| `proxy` | object | Apify Residential (SE) | Proxy for free-tier runs; paid runs use a built-in Swedish residential pool |

#### 📤 Output overview

One row per property. Prices are kept both as Hemnet's raw Swedish strings (e.g. `"1 695 000 kr"`) and as parsed integers (`1695000`) for easy sorting and filtering.

##### Output sample

```json
{
  "rowType": "property",
  "id": "21684506",
  "slug": "forsaker-nod431-21684506",
  "url": "https://www.hemnet.se/bostad/forsaker-nod431-21684506",
  "recordType": "PROJECT",
  "housingForm": "Lägenhet",
  "housingFormSymbol": "APARTMENT",
  "streetAddress": "NOD431",
  "locationDescription": "Forsåker, Mölndals kommun",
  "latitude": 57.6544724,
  "longitude": 12.0235844,
  "askingPrice": "fr. 1 695 000 kr",
  "askingPriceValue": 1695000,
  "fee": "fr. 2 683 kr/mån",
  "feeValue": 2683,
  "squareMeterPrice": "fr. 48 962 kr/m²",
  "squareMeterPriceValue": 48962,
  "rooms": "1-4 rum",
  "roomsValue": 4,
  "livingArea": "34-86 m²",
  "livingAreaValue": 34,
  "newConstruction": true,
  "publishedAt": "2026-07-06T03:00:01.000Z",
  "brokerName": "Pernilla Tilly-Meijer",
  "brokerAgencyName": "Nordr Sverige AB, Region Göteborg",
  "labels": [
    { "text": "28 lediga bostäder", "identifier": "UNITS_LEFT", "category": "STATE" },
    { "text": "Nybyggnadsprojekt", "identifier": "NEW_CONSTRUCTION_PROJECT", "category": "TYPE" }
  ],
  "images": ["https://bilder.hemnet.se/images/1200x/d7/41/d741fef6fc9efee92e4e3470012def03.jpg"],
  "sourceUrl": "https://www.hemnet.se/bostader",
  "sourceMode": "search",
  "scrapedAt": "2026-07-06T03:30:37.720Z"
}
````

##### Key output fields

| Field | Description |
|---|---|
| `id`, `slug`, `url` | Hemnet property ID, slug and canonical detail URL |
| `askingPrice` / `askingPriceValue` | Asking price as shown / parsed integer (kr) |
| `fee` / `feeValue` | Monthly fee as shown / parsed integer (kr/month) |
| `squareMeterPrice` / `squareMeterPriceValue` | Price per m² as shown / parsed integer |
| `rooms` / `roomsValue` | Rooms as shown (e.g. "3 rum") / numeric |
| `livingArea` / `livingAreaValue` | Living area as shown / numeric (m²) |
| `streetAddress`, `locationDescription` | Address and area/municipality |
| `latitude`, `longitude` | GPS coordinates |
| `housingForm`, `housingFormSymbol` | Type name ("Lägenhet", "Villa") and symbol (APARTMENT, HOUSE) |
| `recordType`, `newConstruction`, `upcoming` | Listing type and status flags |
| `brokerName`, `brokerAgencyName` | Listing broker and agency |
| `labels` | Hemnet status/type badges (open house, new construction, price change, …) |
| `images`, `thumbnails` | Full-size and thumbnail image URLs |
| `description` | Listing description snippet (results card) |
| `fullDescription`, `constructionYear`, `tenure` | Added when `scrapeDetails` is on |

#### ❓ FAQ

**Does it scrape sold listings?**
This actor targets **for-sale** listings (`/bostader`, `/till-salu`, `/bostad/{slug}`). Sold-listing pages have a different shape and are out of scope for now.

**How many properties can I get per search?**
Hemnet shows up to ~2,500 results per search (50 pages × 50 properties). Use precise filters in your results URL to narrow a large area into targeted, complete result sets.

**Why do some rows have empty `fee` or `squareMeterPrice`?**
Those fields don't apply to every listing (e.g. plots and some new-construction projects). Address, price, location, coordinates and images are present on virtually every row.

**Do I need my own proxies?**
No. Paid runs use a built-in Swedish residential pool automatically. Free-tier runs use Apify Residential (country SE) by default.

**Is the price in the results reliable?**
Yes — it's read from Hemnet's own embedded data, the same numbers shown on the site, plus a parsed integer variant for sorting.

#### 🛟 Support

Found a field you need that isn't in the output, or a listing type you'd like supported? Open an issue on the actor's **Issues** tab and it will be looked at.

#### 🔎 Explore more scrapers

This actor is part of a portfolio of fast, HTTP-based scrapers for real-estate and directory sites. Check the publisher's profile for more.

#### ⚠️ Disclaimer

This actor collects only **publicly available** data from Hemnet's for-sale results and property pages. It does not access any login-gated, private or personal account data. You are responsible for using the scraped data in compliance with Hemnet's terms, applicable laws (including GDPR where personal data such as broker names is involved), and the purpose limitations that apply to your use case. Use the data responsibly and lawfully.

#### 🔑 SEO keywords

Hemnet scraper, Hemnet API, scrape Hemnet, Hemnet property scraper, Swedish real estate data, Sweden property listings scraper, bostäder till salu data, Hemnet listings export, real estate data Sweden, property price monitoring Sweden, Hemnet crawler, hemnet.se scraper, Swedish housing market data, lägenhet villa data, property coordinates Sweden.

# Actor input Schema

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

Free-text locations to search for-sale listings, e.g. `Stockholm`, `Göteborg`, `Malmö`. Hemnet resolves each to a location and its newest for-sale results are paginated. For precise filters (price, rooms, type), build the search on hemnet.se and paste the URL under "Results / search URLs" instead.

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

Hemnet for-sale results pages (e.g. `https://www.hemnet.se/bostader?location_ids[]=17744` or `https://www.hemnet.se/till-salu/stockholm`) and/or property-detail URLs (`https://www.hemnet.se/bostad/{slug}`). Auto-classified and paginated.

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

For each property found in a results page, also fetch its detail page to add the full description, construction year and tenure. Richer rows, but ~2× the requests. Off = the results-card fields (already ~40 per property). Property URLs you paste are always fully detailed.

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

Hard cap on rows across the entire run. Each row is one paid `property` event. Default 1000. Free-tier users are additionally capped at 100.

## `maxItemsPerSearch` (type: `integer`):

Cap per location keyword / results URL. Hemnet returns 50 properties per page (up to ~2500 viewable per search). Default 1000.

## `maxConcurrency` (type: `integer`):

Parallel HTTP requests. Hemnet is protected by Cloudflare — keep this moderate (4–8). Default 6.

## `maxRequestRetries` (type: `integer`):

Per-request retry budget on Cloudflare challenges (403), 429 and network errors. Each retry rotates to a fresh Swedish residential IP. Default 20 (the challenge is flaky — more retries help break through).

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

Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.

## Actor input object example

```json
{
  "searchQueries": [
    "Stockholm"
  ],
  "startUrls": [],
  "scrapeDetails": false,
  "maxItems": 1000,
  "maxItemsPerSearch": 1000,
  "maxConcurrency": 6,
  "maxRequestRetries": 20
}
```

# 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 = {
    "searchQueries": [
        "Stockholm"
    ],
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/hemnet-property-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 = {
    "searchQueries": ["Stockholm"],
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/hemnet-property-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 '{
  "searchQueries": [
    "Stockholm"
  ],
  "startUrls": []
}' |
apify call memo23/hemnet-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hemnet Property Scraper - Sweden Listings Data",
        "description": "Scrape Swedish property listings from Hemnet.se by location keyword or by pasting results/property URLs. One row per property: asking price, monthly fee, rooms, living area, address, GPS coordinates, housing form, broker, labels and images. Optional detail-page enrichment. Export JSON, CSV or Excel.",
        "version": "0.1",
        "x-build-id": "Ef181CwMxE6XnqNta"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~hemnet-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-hemnet-property-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/memo23~hemnet-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-hemnet-property-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/memo23~hemnet-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-hemnet-property-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": {
                    "searchQueries": {
                        "title": "Location keywords",
                        "type": "array",
                        "description": "Free-text locations to search for-sale listings, e.g. `Stockholm`, `Göteborg`, `Malmö`. Hemnet resolves each to a location and its newest for-sale results are paginated. For precise filters (price, rooms, type), build the search on hemnet.se and paste the URL under \"Results / search URLs\" instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Results / search & property URLs",
                        "type": "array",
                        "description": "Hemnet for-sale results pages (e.g. `https://www.hemnet.se/bostader?location_ids[]=17744` or `https://www.hemnet.se/till-salu/stockholm`) and/or property-detail URLs (`https://www.hemnet.se/bostad/{slug}`). Auto-classified and paginated.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeDetails": {
                        "title": "Scrape property detail pages",
                        "type": "boolean",
                        "description": "For each property found in a results page, also fetch its detail page to add the full description, construction year and tenure. Richer rows, but ~2× the requests. Off = the results-card fields (already ~40 per property). Property URLs you paste are always fully detailed.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max results (whole run)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on rows across the entire run. Each row is one paid `property` event. Default 1000. Free-tier users are additionally capped at 100.",
                        "default": 1000
                    },
                    "maxItemsPerSearch": {
                        "title": "Max properties per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap per location keyword / results URL. Hemnet returns 50 properties per page (up to ~2500 viewable per search). Default 1000.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max parallel requests",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Parallel HTTP requests. Hemnet is protected by Cloudflare — keep this moderate (4–8). Default 6.",
                        "default": 6
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per-request retry budget on Cloudflare challenges (403), 429 and network errors. Each retry rotates to a fresh Swedish residential IP. Default 20 (the challenge is flaky — more retries help break through).",
                        "default": 20
                    },
                    "proxy": {
                        "title": "Proxy configuration (optional override)",
                        "type": "object",
                        "description": "Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
