# Ja.is Scraper (`crawlerbros/ja-is-scraper`) Actor

Scrape Ja.is, Iceland's national business and phone directory. Search by name or keyword, browse by business category or town, or fetch specific listing URLs directly. Returns names, addresses, phone numbers, websites, GPS coordinates, and Icelandic national IDs (kennitala).

- **URL**: https://apify.com/crawlerbros/ja-is-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Integrations
- **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

## Ja.is Scraper

Scrape [Ja.is](https://ja.is), Iceland's national business and phone directory. Search by name, keyword, business category, or town, or fetch specific Ja.is listing pages directly. Returns names, addresses, phone numbers, websites, social media links, GPS coordinates, opening hours, and Icelandic national IDs (kennitala) for both businesses (yellow pages) and people (white pages). No login, no cookies, no paid API key required.

### What this actor does

- **Four modes:** `search` (free text), `byCategory` (browse a trade/industry), `byCity` (browse a town), `byUrl` (fetch specific listing pages)
- **Both directories:** business/yellow-pages listings and person/white-pages listings, in one dataset
- **Full Icelandic character support** — þ, ð, æ, ö, á, é, í, ó, ú, ý round-trip correctly in both search queries and output, with accent-insensitive keyword matching
- **Detail enrichment** — optionally visits each listing's page to add phone number, website, social media links, GPS coordinates, opening hours, and kennitala (national ID / VAT number)
- **Filters** — city, business category, people/businesses-only, must-have-phone, must-have-website, free-text keyword
- **Empty fields are omitted** — every record only contains fields Ja.is actually returned

### Output per listing

Common to every record:
- `recordType` — `"business"` or `"person"`
- `sourceUrl` — the canonical Ja.is page for this listing
- `name`
- `occupation` — trade / job title / primary business activity
- `address`, `postalCode`, `city`
- `phone`, `phonePretty` (when "Fetch full details" is on)
- `scrapedAt`

Business-only fields:
- `clusterKey`, `hashid` — Ja.is's internal listing identifiers
- `categories[]` — business type tags (e.g. `bakarí`, `veitingastaður`)
- `isBranch`, `isPrimary` — whether this is a branch location of a larger registered company
- `website` — the business's own homepage
- `facebook`, `instagram`, `linkedin`, `twitter`, `youtube`, `tiktok` — social media profile links, when published on the listing (via "Fetch full details")
- `kennitala` — Icelandic national ID / VAT number
- `logoUrl`, `logoUrlLarge`
- `latitude`, `longitude`
- `openingHours` — structured weekly schedule, when published
- `isOpenNow` — whether the business is open at the moment the listing was scraped, when Ja.is publishes hours for it
- `openingStatus` — human-readable status text, e.g. `Lokað`, `Sólarhringsopnun`

Person-only fields:
- `hashid`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `byCity` / `byUrl` |
| `searchQuery` | string | `bakarí` | Free-text query (mode=search; also combinable with city on byCity) |
| `category` | string (enum) | `bakarí` | Business category to browse (mode=byCategory) |
| `city` | string (enum) | – | Restrict to one Icelandic town; usable with any mode |
| `urls` | array | – | Direct Ja.is listing URLs (mode=byUrl) |
| `searchScope` | string (enum) | `all` | `all` / `people` / `businesses` |
| `fetchDetails` | bool | `true` | Visit each listing's page for phone/website/coordinates/hours |
| `hasPhone` | bool | `false` | Only keep listings with a phone number |
| `hasWebsite` | bool | `false` | Only keep businesses with a website |
| `containsKeyword` | string | – | Extra client-side text filter (accent-insensitive) |
| `maxItems` | int | `30` | Hard cap on emitted records (1–500) |

#### Example: search by keyword

```json
{
  "mode": "search",
  "searchQuery": "bakarí",
  "maxItems": 30
}
````

#### Example: browse a category in one town

```json
{
  "mode": "byCategory",
  "category": "hárgreiðslustofa",
  "city": "Akureyri",
  "maxItems": 50
}
```

#### Example: fetch specific listings

```json
{
  "mode": "byUrl",
  "urls": ["https://ja.is/myllan-bakari/", "https://ja.is/e/eZZdk/"]
}
```

### Use cases

- **Lead generation** — build a list of businesses in a category/town with phone numbers and websites
- **Market research** — map the density and distribution of a trade across Icelandic towns
- **Data enrichment** — resolve a known company or person name to their address, phone, and kennitala
- **Directory migration** — bulk-export a category of listings for import into a CRM

### FAQ

**Does this require an Apify proxy or login?** No. Ja.is's public search and listing pages are freely accessible; the actor uses no cookies, no API key, and no proxy by default.

**What's a "kennitala"?** Iceland's national identification number, used for both individuals and companies (equivalent to a US EIN/SSN or a VAT number). The actor extracts it for businesses when published on their listing page.

**Why do some listings have fewer fields than others?** Ja.is only publishes what each business or person has chosen to list — not every listing has a website, opening hours, or GPS coordinates. The actor never fabricates missing data; a field is simply omitted when the source doesn't provide it.

**How does city/category filtering work?** Ja.is's search matches every query word against a listing's name, address, town, and category fields. The actor also re-checks the result client-side so the output strictly matches your filter, even if the underlying search is fuzzy.

**Does it handle Icelandic letters like þ, ð, æ, ö?** Yes — both in your search input and in the returned data. Filtering (e.g. `containsKeyword`) is accent-insensitive, so `Kopavogur` and `Kópavogur` match the same listings.

**What towns and categories are available?** The `city` and `category` dropdowns cover Iceland's major municipalities and the most common trades/industries. `searchQuery` accepts any free text if you need a town or category outside the curated lists.

**Is `fetchDetails` worth the extra time?** It's what fills in `phone`, `website`, `latitude`/`longitude`, `kennitala`, and `openingHours` — for a phone/business directory these are usually the fields you actually want. Turn it off only if you need a fast, lightweight name/address list.

**How fresh is the data?** Ja.is is Iceland's official phone-book and business-registry front end, updated continuously as businesses and individuals update their own listings.

### Limitations

- **Results per query are capped by Ja.is itself.** A single search/category/city query typically returns up to ~12 business listings and ~18 person listings — this mirrors what Ja.is's own website shows as "quick results" and is not a pagination bug in the actor. To collect more listings for a broad category, narrow by city or run multiple category/keyword combinations rather than raising `maxItems` on one broad query.
- **`hasPhone` / `hasWebsite` filters require `fetchDetails: true`.** Phone and website are only discovered by visiting each listing's page; with `fetchDetails` off, these filters will drop every result.

# Actor input Schema

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

What to fetch.

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

Free-text search — matches names, addresses, occupations, and categories. Supports Icelandic characters (þ, ð, æ, ö, á, é, í, ó, ú, ý). Example: `bakari`, `Jón Jónsson`, `Kringlan`.

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

A business category / trade to browse. Combine with City to narrow to one town.

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

Restrict results to one Icelandic town or municipality. Usable with any mode (mode=byCity requires it; search/byCategory treat it as an optional narrower).

## `urls` (type: `array`):

Direct Ja.is business or person page URLs, e.g. `https://ja.is/myllan-bakari/` or `https://ja.is/e/eZZdk/`.

## `searchScope` (type: `string`):

Which listing types to include (mode=search / byCategory / byCity).

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

Visit each listing's detail page to add phone number, website, GPS coordinates, and national ID (kennitala). Slower but far more complete. Turn off for a faster, lighter scrape.

## `hasPhone` (type: `boolean`):

Drop listings where no phone number could be found. Requires Fetch full details.

## `hasWebsite` (type: `boolean`):

Drop listings where no website could be found. Requires Fetch full details.

## `containsKeyword` (type: `string`):

Extra client-side filter: keep only listings whose name, address, city, or category contains this text (accent-insensitive).

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

Hard cap on emitted records. Note: Ja.is's own live-search API (which powers mode=search/byCategory/byCity) is itself capped at roughly 12-20 matches per query/category/city, regardless of this setting or the site's own displayed total-result count -- confirmed live (the `count` request parameter has no effect past that cap). mode=byUrl is not affected, since each URL is fetched independently.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "bakarí",
  "category": "bakarí",
  "city": "",
  "urls": [],
  "searchScope": "all",
  "fetchDetails": true,
  "hasPhone": false,
  "hasWebsite": false,
  "maxItems": 30
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped Ja.is people and business records.

# 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",
    "searchQuery": "bakarí",
    "category": "bakarí",
    "city": "",
    "urls": [],
    "searchScope": "all",
    "fetchDetails": true,
    "hasPhone": false,
    "hasWebsite": false,
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/ja-is-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",
    "searchQuery": "bakarí",
    "category": "bakarí",
    "city": "",
    "urls": [],
    "searchScope": "all",
    "fetchDetails": True,
    "hasPhone": False,
    "hasWebsite": False,
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/ja-is-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",
  "searchQuery": "bakarí",
  "category": "bakarí",
  "city": "",
  "urls": [],
  "searchScope": "all",
  "fetchDetails": true,
  "hasPhone": false,
  "hasWebsite": false,
  "maxItems": 30
}' |
apify call crawlerbros/ja-is-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ja.is Scraper",
        "description": "Scrape Ja.is, Iceland's national business and phone directory. Search by name or keyword, browse by business category or town, or fetch specific listing URLs directly. Returns names, addresses, phone numbers, websites, GPS coordinates, and Icelandic national IDs (kennitala).",
        "version": "1.0",
        "x-build-id": "7PgRv6UNa3AQqK7hP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~ja-is-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-ja-is-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~ja-is-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-ja-is-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~ja-is-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-ja-is-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",
                            "byCategory",
                            "byCity",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search / byCity)",
                        "type": "string",
                        "description": "Free-text search — matches names, addresses, occupations, and categories. Supports Icelandic characters (þ, ð, æ, ö, á, é, í, ó, ú, ý). Example: `bakari`, `Jón Jónsson`, `Kringlan`.",
                        "default": "bakarí"
                    },
                    "category": {
                        "title": "Business category (mode=byCategory)",
                        "enum": [
                            "bakarí",
                            "kaffihús",
                            "veitingastaður",
                            "skyndibitastaður",
                            "ísbúð",
                            "hótel",
                            "gistiheimili",
                            "ferðaskrifstofa",
                            "lögfræðingur",
                            "lögmannsstofa",
                            "endurskoðandi",
                            "fasteignasala",
                            "tryggingafélag",
                            "banki",
                            "tannlæknir",
                            "læknir",
                            "dýralæknir",
                            "sjúkraþjálfun",
                            "sálfræðingur",
                            "apótek",
                            "hárgreiðslustofa",
                            "snyrtistofa",
                            "naglastofa",
                            "líkamsræktarstöð",
                            "bifreiðaverkstæði",
                            "dekkjaverkstæði",
                            "bílaleiga",
                            "bílasala",
                            "leigubílastöð",
                            "rafvirki",
                            "pípulagningamaður",
                            "málari",
                            "smiður",
                            "byggingaverktaki",
                            "arkitekt",
                            "verkfræðistofa",
                            "tölvuþjónusta",
                            "hönnun",
                            "ljósmyndari",
                            "verslun",
                            "fataverslun",
                            "skóverslun",
                            "bókabúð",
                            "blómabúð",
                            "gæludýraverslun",
                            "húsgagnaverslun",
                            "raftækjaverslun",
                            "byggingavöruverslun",
                            "flutningafyrirtæki",
                            "ræstingaþjónusta",
                            "garðyrkja",
                            "leikskóli"
                        ],
                        "type": "string",
                        "description": "A business category / trade to browse. Combine with City to narrow to one town."
                    },
                    "city": {
                        "title": "City / town",
                        "enum": [
                            "",
                            "Reykjavík",
                            "Kópavogur",
                            "Hafnarfjörður",
                            "Akureyri",
                            "Reykjanesbær",
                            "Garðabær",
                            "Mosfellsbær",
                            "Selfoss",
                            "Akranes",
                            "Ísafjörður",
                            "Vestmannaeyjar",
                            "Keflavík",
                            "Egilsstaðir",
                            "Borgarnes",
                            "Húsavík",
                            "Sauðárkrókur",
                            "Seltjarnarnes",
                            "Þorlákshöfn",
                            "Grindavík",
                            "Hveragerði",
                            "Dalvík",
                            "Bolungarvík",
                            "Stykkishólmur",
                            "Vopnafjörður",
                            "Höfn",
                            "Blönduós",
                            "Siglufjörður",
                            "Hvolsvöllur",
                            "Hella",
                            "Neskaupstaður",
                            "Eskifjörður",
                            "Reyðarfjörður"
                        ],
                        "type": "string",
                        "description": "Restrict results to one Icelandic town or municipality. Usable with any mode (mode=byCity requires it; search/byCategory treat it as an optional narrower).",
                        "default": ""
                    },
                    "urls": {
                        "title": "Ja.is listing URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Direct Ja.is business or person page URLs, e.g. `https://ja.is/myllan-bakari/` or `https://ja.is/e/eZZdk/`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchScope": {
                        "title": "Result type",
                        "enum": [
                            "all",
                            "people",
                            "businesses"
                        ],
                        "type": "string",
                        "description": "Which listing types to include (mode=search / byCategory / byCity).",
                        "default": "all"
                    },
                    "fetchDetails": {
                        "title": "Fetch full details (phone, website, coordinates)",
                        "type": "boolean",
                        "description": "Visit each listing's detail page to add phone number, website, GPS coordinates, and national ID (kennitala). Slower but far more complete. Turn off for a faster, lighter scrape.",
                        "default": true
                    },
                    "hasPhone": {
                        "title": "Only listings with a phone number",
                        "type": "boolean",
                        "description": "Drop listings where no phone number could be found. Requires Fetch full details.",
                        "default": false
                    },
                    "hasWebsite": {
                        "title": "Only businesses with a website",
                        "type": "boolean",
                        "description": "Drop listings where no website could be found. Requires Fetch full details.",
                        "default": false
                    },
                    "containsKeyword": {
                        "title": "Must contain keyword",
                        "type": "string",
                        "description": "Extra client-side filter: keep only listings whose name, address, city, or category contains this text (accent-insensitive)."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records. Note: Ja.is's own live-search API (which powers mode=search/byCategory/byCity) is itself capped at roughly 12-20 matches per query/category/city, regardless of this setting or the site's own displayed total-result count -- confirmed live (the `count` request parameter has no effect past that cap). mode=byUrl is not affected, since each URL is fetched independently.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
