# Eniro Scraper - Swedish Business Directory (`crawlerbros/eniro-scraper`) Actor

Scrape Eniro.se (Sweden's leading business directory) listings. Search by category/keyword and city (or nationwide), or fetch full business profiles by URL/ID. Get names, addresses, phone numbers, categories, ratings, opening hours, websites, coordinates, and images.

- **URL**: https://apify.com/crawlerbros/eniro-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Eniro Scraper

Scrape **Eniro.se** — Sweden's leading business and phone directory. Search by category/keyword and city (or nationwide across all of Sweden), or fetch full business profiles by direct URL or business ID. Get names, addresses, phone numbers, categories, ratings, review counts, opening hours, websites, email addresses, social media links, organization numbers, coordinates, and images. HTTP-only, no auth, no cookies, no paid proxy required.

### What this actor does

- **Two modes:** `search` (category/keyword + city) and `detail` (direct URL/ID lookup)
- **Nationwide or city-scoped search:** leave city empty to search all of Sweden
- **Rich business profiles:** optional detail-page enrichment adds rating, review count, opening hours, website, email, social media links, organization number, description, coordinates, and image gallery
- **Filters:** minimum rating, ratings-only, website-only, sort by relevance/rating/name
- **Swedish-localized opening hours:** day names in Swedish (Måndag, Tisdag, ...)
- **Empty fields are omitted** — you'll never see `null`, `""`, or `[]` in the output

### Output per business

- `businessId` — Eniro's internal numeric business ID
- `name` — business name
- `businessType` — schema.org business type (e.g. `Restaurant`, `HairSalon`, `Dentist`)
- `category`, `categories[]` — Eniro's category taxonomy chain (detail pages only)
- `street`, `postalCode`, `city`, `region`, `country` — postal address
- `phone` — phone number
- `email` — business email address (detail pages only, when Eniro has one on file)
- `website` — business website (detail pages only)
- `organizationNumber` — Swedish organization number, formatted `NNNNNN-NNNN` (detail pages only, when on file)
- `facebookUrl`, `instagramUrl`, `linkedinUrl`, `twitterUrl`, `youtubeUrl`, `tiktokUrl` — social media profile links (detail pages only, when on file)
- `description` — short business description (detail pages only)
- `keywords[]` — search tags / services / brands associated with the business, e.g. `["balayage", "herrfrisör", "loreal"]` (detail pages only, when on file)
- `rating`, `reviewCount` — average customer rating (1–5) and number of reviews (detail pages only)
- `openingHours[]` — structured weekly schedule: `{ day, opens, closes }` with Swedish day names
- `openingHoursText` — human-readable summary of the weekly schedule
- `latitude`, `longitude` — geographic coordinates (detail pages only)
- `mapUrl` — Eniro directions/map link
- `logoUrl`, `logoUrlOriginal` — business logo image (rehosted for reliable access; original Eniro CDN URL also included)
- `images[]`, `imagesOriginal[]` — business photo gallery, rehosted for reliable access (detail pages only)
- `searchQuery`, `searchCity` — the query/city that produced this result (mode=search only)
- `sourceUrl` — canonical Eniro business page URL
- `recordType: "business"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `detail` |
| `query` | string | `pizzeria` | Category/keyword, pick from list or choose "Custom" (mode=search) |
| `customQuery` | string | – | Free-text category/keyword, overrides `query` (mode=search) |
| `city` | string | `Stockholm` | Swedish city; leave empty for nationwide search (mode=search) |
| `sortBy` | string | `relevance` | `relevance` / `rating` / `name` |
| `minRating` | string | – | Minimum star rating (`1`–`5`); needs `fetchDetails` |
| `ratedOnly` | boolean | `false` | Only businesses with at least one rating; needs `fetchDetails` |
| `hasWebsiteOnly` | boolean | `false` | Only businesses with a listed website; needs `fetchDetails` |
| `fetchDetails` | boolean | `false` | Visit each business's profile page for rating, hours, website, coordinates, images |
| `businessUrls` | array | – | Eniro business URLs or numeric IDs to fetch (mode=detail) |
| `maxItems` | integer | `50` | Hard cap on returned records (1–1000) |

#### Example: search a category in a city

```json
{
  "mode": "search",
  "query": "frisör",
  "city": "Göteborg",
  "maxItems": 50
}
````

#### Example: nationwide search with full profiles

```json
{
  "mode": "search",
  "customQuery": "veterinär",
  "city": "",
  "fetchDetails": true,
  "minRating": "4",
  "maxItems": 30
}
```

#### Example: top-rated results only, sorted

```json
{
  "mode": "search",
  "query": "restaurang",
  "city": "Malmö",
  "fetchDetails": true,
  "ratedOnly": true,
  "sortBy": "rating",
  "maxItems": 40
}
```

#### Example: fetch specific business profiles

```json
{
  "mode": "detail",
  "businessUrls": [
    "https://www.eniro.se/pizzeria+florida+viskafors/14839034/firma",
    "14839034"
  ]
}
```

### Use cases

- **Lead generation** — build prospect lists of Swedish businesses by category and city
- **Market research** — analyze business density and ratings across Swedish regions
- **Local SEO agencies** — audit client and competitor directory listings
- **Data enrichment** — append verified phone numbers, addresses, and websites to a CRM
- **Franchise/expansion planning** — map existing competitor locations before entering a new city

### FAQ

**What is the data source?**
All data comes from the public Eniro.se website, Sweden's largest business and phone directory.

**Is this affiliated with Eniro?**
No — this is an independent, third-party actor that reads Eniro's public listing pages. It is not affiliated with or endorsed by Eniro Sverige AB.

**Why are `rating`, `website`, and `openingHours` sometimes missing?**
Those fields only appear on a business's full profile page. Enable `fetchDetails` to fetch them — without it, only the fields visible on the search-results page are returned (name, address, phone, category type).

**Can I search all of Sweden at once?**
Yes — leave `city` empty and the search covers the entire country.

**What Swedish weekday names are used in `openingHours`?**
`Måndag`, `Tisdag`, `Onsdag`, `Torsdag`, `Fredag`, `Lördag`, `Söndag` (Monday–Sunday).

**Does the actor return individual written reviews?**
No — Eniro's business pages expose an aggregate `rating` and `reviewCount` but not per-review text, so only the aggregate figures are included.

**Why don't all businesses have a `website`, `email`, or social media links?**
Not every Eniro listing includes these; each field is only included when Eniro itself has that information on file for the business.

**How fresh is the data?**
Each run scrapes Eniro's live pages in real time, so results reflect the current state of the directory.

**What happens if my category/keyword doesn't match any real Eniro category?**
Eniro's own search does not strictly require an exact keyword match — for a keyword it doesn't recognize, it may still return a broader set of businesses for the given city rather than zero results. This is upstream Eniro search behavior, not an actor bug; using one of the curated category options (or a real Swedish business term) gives the most precise results.

# Actor input Schema

## `mode` (type: `string`):

What to fetch: search by keyword/category & city, or fetch full business profiles from direct URLs/IDs.

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

Business category or keyword to search for. Pick a common category from the list, or choose 'Custom' and type your own in the field below (mode=search).

## `customQuery` (type: `string`):

Free-text category or keyword not in the curated list above, e.g. 'skorstensfejare' or 'IT-konsult' (mode=search). Takes priority over 'Category / keyword' when set. Use correct Swedish spelling with å/ä/ö -- Eniro's own search does not fuzzy-match ASCII-folded keywords.

## `city` (type: `string`):

Swedish city or town to search in, e.g. 'Stockholm', 'Göteborg', 'Malmö' (mode=search). Leave empty to search all of Sweden nationwide.

## `sortBy` (type: `string`):

How to order the returned results (mode=search). Applied after fetching, since Eniro's own listing order is relevance-based.

## `ratedOnly` (type: `boolean`):

Only return businesses that have at least one customer rating (mode=search). Requires 'Fetch full business profiles' to be enabled, since ratings only appear on detail pages.

## `minRating` (type: `string`):

Only return businesses rated at least this many stars, e.g. '4' for 4.0+ (mode=search). Requires 'Fetch full business profiles' to be enabled, since ratings only appear on detail pages.

## `hasWebsiteOnly` (type: `boolean`):

Only return businesses that list a website (mode=search). Requires 'Fetch full business profiles' to be enabled, since websites only appear on detail pages.

## `fetchDetails` (type: `boolean`):

For each search result, also visit its business profile page to collect rating, opening hours, website, description, coordinates, images, and full category chain. Slower, but far richer output (mode=search).

## `businessUrls` (type: `array`):

Direct Eniro business URLs (e.g. https://www.eniro.se/<name>/<id>/firma) or bare numeric business IDs to fetch, one per line. Use the 'sourceUrl' or 'businessId' field from search results.

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

Hard cap on the number of business records to return.

## Actor input object example

```json
{
  "mode": "search",
  "query": "pizzeria",
  "city": "Stockholm",
  "sortBy": "relevance",
  "ratedOnly": false,
  "minRating": "",
  "hasWebsiteOnly": false,
  "fetchDetails": false,
  "businessUrls": [
    "14839034"
  ],
  "maxItems": 50
}
```

# Actor output Schema

## `businesses` (type: `string`):

Dataset containing all scraped Eniro business listings.

# 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 = {
    "mode": "search",
    "query": "pizzeria",
    "city": "Stockholm",
    "sortBy": "relevance",
    "ratedOnly": false,
    "minRating": "",
    "hasWebsiteOnly": false,
    "fetchDetails": false,
    "businessUrls": [
        "14839034"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/eniro-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 = {
    "mode": "search",
    "query": "pizzeria",
    "city": "Stockholm",
    "sortBy": "relevance",
    "ratedOnly": False,
    "minRating": "",
    "hasWebsiteOnly": False,
    "fetchDetails": False,
    "businessUrls": ["14839034"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/eniro-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 '{
  "mode": "search",
  "query": "pizzeria",
  "city": "Stockholm",
  "sortBy": "relevance",
  "ratedOnly": false,
  "minRating": "",
  "hasWebsiteOnly": false,
  "fetchDetails": false,
  "businessUrls": [
    "14839034"
  ],
  "maxItems": 50
}' |
apify call crawlerbros/eniro-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eniro Scraper - Swedish Business Directory",
        "description": "Scrape Eniro.se (Sweden's leading business directory) listings. Search by category/keyword and city (or nationwide), or fetch full business profiles by URL/ID. Get names, addresses, phone numbers, categories, ratings, opening hours, websites, coordinates, and images.",
        "version": "1.0",
        "x-build-id": "imYIe53GHDpVm7Pdg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~eniro-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-eniro-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/crawlerbros~eniro-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-eniro-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/crawlerbros~eniro-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-eniro-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "detail"
                        ],
                        "type": "string",
                        "description": "What to fetch: search by keyword/category & city, or fetch full business profiles from direct URLs/IDs.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Category / keyword",
                        "enum": [
                            "custom",
                            "pizzeria",
                            "restaurang",
                            "frisör",
                            "tandläkare",
                            "advokat",
                            "elektriker",
                            "rörmokare",
                            "målare",
                            "snickare",
                            "bilverkstad",
                            "hotell",
                            "blomsterhandlare",
                            "revisor",
                            "fastighetsmäklare",
                            "veterinär",
                            "optiker",
                            "apotek",
                            "gym",
                            "massage",
                            "byggföretag",
                            "taxi",
                            "flyttfirma",
                            "trädgårdsanläggning",
                            "försäkringsmäklare",
                            "hundfrisör",
                            "glasmästare",
                            "låssmed",
                            "redovisningsbyrå",
                            "kafé",
                            "bageri"
                        ],
                        "type": "string",
                        "description": "Business category or keyword to search for. Pick a common category from the list, or choose 'Custom' and type your own in the field below (mode=search).",
                        "default": "pizzeria"
                    },
                    "customQuery": {
                        "title": "Custom category/keyword (overrides selection above)",
                        "type": "string",
                        "description": "Free-text category or keyword not in the curated list above, e.g. 'skorstensfejare' or 'IT-konsult' (mode=search). Takes priority over 'Category / keyword' when set. Use correct Swedish spelling with å/ä/ö -- Eniro's own search does not fuzzy-match ASCII-folded keywords."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Swedish city or town to search in, e.g. 'Stockholm', 'Göteborg', 'Malmö' (mode=search). Leave empty to search all of Sweden nationwide.",
                        "default": "Stockholm"
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "rating",
                            "name"
                        ],
                        "type": "string",
                        "description": "How to order the returned results (mode=search). Applied after fetching, since Eniro's own listing order is relevance-based.",
                        "default": "relevance"
                    },
                    "ratedOnly": {
                        "title": "Only businesses with ratings",
                        "type": "boolean",
                        "description": "Only return businesses that have at least one customer rating (mode=search). Requires 'Fetch full business profiles' to be enabled, since ratings only appear on detail pages.",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Only return businesses rated at least this many stars, e.g. '4' for 4.0+ (mode=search). Requires 'Fetch full business profiles' to be enabled, since ratings only appear on detail pages.",
                        "default": ""
                    },
                    "hasWebsiteOnly": {
                        "title": "Only businesses with a website",
                        "type": "boolean",
                        "description": "Only return businesses that list a website (mode=search). Requires 'Fetch full business profiles' to be enabled, since websites only appear on detail pages.",
                        "default": false
                    },
                    "fetchDetails": {
                        "title": "Fetch full business profiles",
                        "type": "boolean",
                        "description": "For each search result, also visit its business profile page to collect rating, opening hours, website, description, coordinates, images, and full category chain. Slower, but far richer output (mode=search).",
                        "default": false
                    },
                    "businessUrls": {
                        "title": "Business profile URLs or IDs (mode=detail)",
                        "type": "array",
                        "description": "Direct Eniro business URLs (e.g. https://www.eniro.se/<name>/<id>/firma) or bare numeric business IDs to fetch, one per line. Use the 'sourceUrl' or 'businessId' field from search results.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on the number of business records to return.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
