# Gulesider Scraper - Norwegian Business Directory (`crawlerbros/gulesider-scraper`) Actor

Scrape Gulesider.no (Norway's leading business directory) listings. Search by category/keyword and city, or fetch full profiles by URL/ID. Get names, addresses, phones, categories, ratings, opening hours, websites, org numbers, coordinates, and images.

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

## Gulesider Scraper

Scrape **Gulesider.no** — Norway's leading business and phone directory. Search by category/keyword and city (or nationwide across all of Norway), or fetch full business profiles by direct URL or business ID. Get names, addresses, phone numbers, categories, ratings, review counts, opening hours, websites, organization numbers, founding dates, VAT status, coordinates, and images. 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, city-scoped, or category-only search:** search by category, by city alone, or both together
- **Rich business profiles:** optional detail-page enrichment adds rating, review count, opening hours, description, coordinates, organization number, founding date, VAT registration status, and social media links
- **Search-page enrichment:** website, online booking/ordering links, and "confirmed info" verification status are picked up directly from search results, no extra page visit required
- **Filters:** minimum rating, ratings-only, website-only, confirmed-info-only, sort by relevance/rating/name
- **Norwegian-localized opening hours:** day names in Norwegian (Mandag, Tirsdag, ...)
- **Empty fields are omitted** — you'll never see `null`, `""`, or `[]` in the output

### Output per business

- `businessId` — Gulesider's internal numeric business ID
- `name` — business name
- `businessType` — schema.org business type (e.g. `Restaurant`, `HairSalon`, `Dentist`)
- `category`, `categories[]` — Gulesider's category taxonomy chain (detail pages only)
- `street`, `postalCode`, `city`, `region`, `country` — postal address
- `phone` — phone number
- `email` — business email (detail pages only, when Gulesider lists one)
- `website` — business website (search results for businesses that show one, or detail pages)
- `bookingUrl` — online ordering/booking link, if the business has one (search results only)
- `isVerified` — whether the business has confirmed its own listing information with Gulesider (search results only)
- `description` — short business description (detail pages only)
- `rating`, `reviewCount` — average customer rating (1–5) and number of reviews (detail pages only)
- `openingHours[]` — structured weekly schedule: `{ day, opens, closes }` with Norwegian day names
- `openingHoursText` — human-readable summary of the weekly schedule
- `latitude`, `longitude` — geographic coordinates (detail pages only)
- `mapUrl` — Gulesider directions/map link
- `logoUrl` — business logo image URL (detail pages only)
- `images[]` — business photo gallery (detail pages only)
- `orgNumber` — Norwegian organization number (Brønnøysundregistrene), when registered (detail pages only)
- `foundingDate` — company founding date, format DD.MM.YYYY (detail pages only, when available)
- `employeeRange` — reported employee count range, e.g. `"1 - 4"` (detail pages only, when available)
- `vatRegistered` — whether the business is VAT-registered (detail pages only, when available)
- `socialLinks[]` — social media profile URLs, e.g. Facebook (detail pages only, when available)
- `searchQuery`, `searchCity` — the query/city that produced this result (mode=search only)
- `sourceUrl` — canonical Gulesider business page URL
- `recordType: "business"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `detail` |
| `query` | string | `pizza` | Category/keyword, pick from list or choose "Custom" (mode=search) |
| `customQuery` | string | – | Free-text category/keyword, overrides `query` (mode=search) |
| `city` | string | `Oslo` | Norwegian city; leave empty for nationwide search (needs a category) |
| `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 |
| `verifiedOnly` | boolean | `false` | Only businesses that confirmed their own listing info |
| `fetchDetails` | boolean | `false` | Visit each business's profile page for rating, hours, org data, coordinates |
| `businessUrls` | array | – | Gulesider 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": "Bergen",
  "maxItems": 50
}
````

#### Example: nationwide search with full profiles

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

#### Example: top-rated, confirmed listings only, sorted

```json
{
  "mode": "search",
  "query": "restaurant",
  "city": "Trondheim",
  "fetchDetails": true,
  "ratedOnly": true,
  "verifiedOnly": true,
  "sortBy": "rating",
  "maxItems": 40
}
```

#### Example: all businesses in a city (no category)

```json
{
  "mode": "search",
  "query": "custom",
  "customQuery": "",
  "city": "Stavanger",
  "maxItems": 50
}
```

#### Example: fetch specific business profiles

```json
{
  "mode": "detail",
  "businessUrls": [
    "https://www.gulesider.no/dinos+pizza+oslo/84424493/bedrift",
    "84424493"
  ]
}
```

### Use cases

- **Lead generation** — build prospect lists of Norwegian businesses by category and city
- **Market research** — analyze business density and ratings across Norwegian regions
- **Local SEO agencies** — audit client and competitor directory listings
- **Data enrichment** — append verified phone numbers, addresses, org numbers, 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 Gulesider.no website, Norway's largest business and phone directory, operated by Eniro Norge AS.

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

**Why are `rating`, `openingHours`, `orgNumber`, and other detail fields sometimes missing?**
Those fields only appear on a business's full profile page. Enable `fetchDetails` to fetch them — without it, only the fields visible directly on the search-results page are returned (name, address, phone, category type, and — for some listings — website, booking link, and confirmed-info status).

**Can I search all of Norway at once?**
Yes — leave `city` empty and provide a category/keyword; the search covers the entire country.

**Can I search a city with no category?**
Yes — set `query` to "Custom" with an empty custom field (or just enter a category value of your choice) and set only `city`; Gulesider returns all businesses in that city.

**Why don't `orgNumber`, `foundingDate`, `employeeRange`, `vatRegistered`, and `socialLinks` appear on every business?**
Gulesider only publishes this firmographic data for businesses with a registered Norwegian organization number (Brønnøysundregistrene). Informal or unregistered listings won't have it.

**What Norwegian weekday names are used in `openingHours`?**
`Mandag`, `Tirsdag`, `Onsdag`, `Torsdag`, `Fredag`, `Lørdag`, `Søndag` (Monday–Sunday).

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

**How fresh is the data?**
Each run scrapes Gulesider'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 Gulesider category?**
Gulesider'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 Gulesider search behavior, not an actor bug; using one of the curated category options (or a real Norwegian business term with correct æ/ø/å spelling) gives the most precise results.

**Why does a `website` or `socialLinks` URL sometimes not load when I check it programmatically?**
The URLs themselves are correct as listed by Gulesider. Two upstream behaviors can make a URL check fail even though the link is valid: (1) a business's own website can be temporarily down or slow to respond, which is outside Gulesider's and this actor's control; (2) Facebook systematically returns 400/404 to unauthenticated, non-browser HTTP requests for profile/page URLs (confirmed even against Gulesider's own official Facebook page) — the link opens normally in an actual browser.

**Does the actor return a separate "map"/"near me" search mode?**
No — `mode=search` and `mode=detail` already return each business's `latitude`/`longitude` and `mapUrl`, which is the same underlying data Gulesider's map view displays; a separate map mode would return the identical business data through a different UI, so it isn't exposed as its own mode.

# 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). Can be left as 'Custom' with an empty custom field if you only want to search by city.

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

Free-text category or keyword not in the curated list above, e.g. 'skorsteinsfeier' or 'IT-konsulent' (mode=search). Takes priority over 'Category / keyword' when set. Use correct Norwegian spelling with ae/oe/aa (æ/ø/å) -- Gulesider's own search does not fuzzy-match ASCII-folded keywords.

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

Norwegian city or town to search in, e.g. 'Oslo', 'Bergen', 'Trondheim' (mode=search). Leave empty to search all of Norway nationwide (requires a category/keyword).

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

How to order the returned results (mode=search). Applied after fetching, since Gulesider'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). Websites are picked up directly from the search-results page for the businesses that show one there; enabling 'Fetch full business profiles' finds additional websites listed only on detail pages.

## `verifiedOnly` (type: `boolean`):

Only return businesses that have confirmed/verified their own listing information with Gulesider (mode=search).

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

For each search result, also visit its business profile page to collect rating, opening hours, description, coordinates, organization number, founding date, VAT status, and social links. Slower, but far richer output (mode=search).

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

Direct Gulesider business URLs (e.g. https://www.gulesider.no/<name>/<id>/bedrift) 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": "pizza",
  "city": "Oslo",
  "sortBy": "relevance",
  "ratedOnly": false,
  "minRating": "",
  "hasWebsiteOnly": false,
  "verifiedOnly": false,
  "fetchDetails": false,
  "businessUrls": [
    "84424493"
  ],
  "maxItems": 50
}
```

# Actor output Schema

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

Dataset containing all scraped Gulesider 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": "pizza",
    "city": "Oslo",
    "sortBy": "relevance",
    "ratedOnly": false,
    "minRating": "",
    "hasWebsiteOnly": false,
    "verifiedOnly": false,
    "fetchDetails": false,
    "businessUrls": [
        "84424493"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/gulesider-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": "pizza",
    "city": "Oslo",
    "sortBy": "relevance",
    "ratedOnly": False,
    "minRating": "",
    "hasWebsiteOnly": False,
    "verifiedOnly": False,
    "fetchDetails": False,
    "businessUrls": ["84424493"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/gulesider-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": "pizza",
  "city": "Oslo",
  "sortBy": "relevance",
  "ratedOnly": false,
  "minRating": "",
  "hasWebsiteOnly": false,
  "verifiedOnly": false,
  "fetchDetails": false,
  "businessUrls": [
    "84424493"
  ],
  "maxItems": 50
}' |
apify call crawlerbros/gulesider-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gulesider Scraper - Norwegian Business Directory",
        "description": "Scrape Gulesider.no (Norway's leading business directory) listings. Search by category/keyword and city, or fetch full profiles by URL/ID. Get names, addresses, phones, categories, ratings, opening hours, websites, org numbers, coordinates, and images.",
        "version": "1.0",
        "x-build-id": "Sv1yQhesyVA6qSbcu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~gulesider-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-gulesider-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~gulesider-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-gulesider-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~gulesider-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-gulesider-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",
                            "pizza",
                            "restaurant",
                            "frisør",
                            "tannlege",
                            "advokat",
                            "elektriker",
                            "rørlegger",
                            "maler",
                            "snekker",
                            "bilverksted",
                            "hotell",
                            "blomsterhandler",
                            "regnskapsfører",
                            "eiendomsmegler",
                            "veterinær",
                            "optiker",
                            "apotek",
                            "treningssenter",
                            "massasje",
                            "byggefirma",
                            "taxi",
                            "flyttebyrå",
                            "gartner",
                            "forsikringsmegler",
                            "hundefrisør",
                            "glassmester",
                            "låsesmed",
                            "revisor",
                            "kafé",
                            "bakeri"
                        ],
                        "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). Can be left as 'Custom' with an empty custom field if you only want to search by city.",
                        "default": "pizza"
                    },
                    "customQuery": {
                        "title": "Custom category/keyword (overrides selection above)",
                        "type": "string",
                        "description": "Free-text category or keyword not in the curated list above, e.g. 'skorsteinsfeier' or 'IT-konsulent' (mode=search). Takes priority over 'Category / keyword' when set. Use correct Norwegian spelling with ae/oe/aa (æ/ø/å) -- Gulesider's own search does not fuzzy-match ASCII-folded keywords."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Norwegian city or town to search in, e.g. 'Oslo', 'Bergen', 'Trondheim' (mode=search). Leave empty to search all of Norway nationwide (requires a category/keyword).",
                        "default": "Oslo"
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "rating",
                            "name"
                        ],
                        "type": "string",
                        "description": "How to order the returned results (mode=search). Applied after fetching, since Gulesider'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). Websites are picked up directly from the search-results page for the businesses that show one there; enabling 'Fetch full business profiles' finds additional websites listed only on detail pages.",
                        "default": false
                    },
                    "verifiedOnly": {
                        "title": "Only businesses with confirmed info",
                        "type": "boolean",
                        "description": "Only return businesses that have confirmed/verified their own listing information with Gulesider (mode=search).",
                        "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, description, coordinates, organization number, founding date, VAT status, and social links. Slower, but far richer output (mode=search).",
                        "default": false
                    },
                    "businessUrls": {
                        "title": "Business profile URLs or IDs (mode=detail)",
                        "type": "array",
                        "description": "Direct Gulesider business URLs (e.g. https://www.gulesider.no/<name>/<id>/bedrift) 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
