# Jofogas Scraper - Hungarian Classifieds Data (`studio-amba/jofogas-scraper`) Actor

Scrape classified listings from Jofogas.hu, Hungary's largest marketplace. Extract prices, seller info, images, location, and category data. No login required.

- **URL**: https://apify.com/studio-amba/jofogas-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Jofogas Scraper - Hungarian Classifieds & Marketplace Data

Extract classified listings, prices, seller information, images, and location data from [Jofogas.hu](https://www.jofogas.hu) — Hungary's largest online marketplace with millions of active listings across electronics, vehicles, real estate, furniture, clothing, sports equipment, and dozens more categories.

### How to scrape Jofogas data

Jofogas Scraper collects structured listing data from Jofogas.hu, Hungary's number one classifieds platform. It searches by keyword, filters by category, location, and price range, and extracts all visible listing data. The scraper handles pagination automatically and uses Playwright for reliable browser-based rendering.

Jofogas.hu (owned by Adevinta/Schibsted) serves over 2 million monthly visitors and is the go-to marketplace in Hungary for buying and selling used goods, similar to Craigslist in the US or Marktplaats in the Netherlands. All prices are in Hungarian Forints (HUF).

**No login or cookies required.**

**Popular use cases:**

- **Market research** — Monitor pricing trends for used electronics, vehicles, furniture, and consumer goods across Hungary.
- **Price comparison** — Track how much specific items (phones, laptops, cars) sell for on the secondhand market vs. retail stores.
- **Lead generation** — Find sellers offering specific products or services in target Hungarian cities and regions.
- **Academic research** — Study classifieds market dynamics, regional pricing differences, and consumer behavior in Hungary.
- **Inventory sourcing** — Discover bulk lots, business liquidations, and wholesale opportunities posted by Hungarian sellers.
- **Competitive intelligence** — Track competitor product listings, pricing strategies, and market positioning across Hungarian categories.

### What data does Jofogas Scraper extract?

Each listing includes:

- **itemTitle** — Title of the classified listing
- **price** — Listed price in HUF (null for negotiable listings)
- **currency** — Currency code (always HUF)
- **category** — Listing category (e.g., Elektronika, Auto-Motor-Jarmu)
- **location** — Seller's city or region in Hungary
- **condition** — Item condition when available (new, used)
- **sellerName** — Name of the seller
- **sellerType** — Type of seller (private or shop)
- **postedDate** — Date the listing was published
- **imageUrl** — Primary listing image URL
- **url** — Full listing URL on Jofogas.hu
- **scrapedAt** — ISO 8601 timestamp of data extraction

### Input parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQuery` | String | `"laptop"` | Keyword search in Hungarian |
| `category` | Enum | `""` | Category filter (elektronika, auto-motor-jarmu, etc.) |
| `location` | String | `""` | City filter (budapest, debrecen, szeged, etc.) |
| `priceFrom` | Integer | — | Minimum price in HUF |
| `priceTo` | Integer | — | Maximum price in HUF |
| `maxResults` | Integer | `50` | Maximum listings to return (up to 5,000) |
| `proxyConfiguration` | Object | HU Residential | Proxy settings for reliability |

#### Tips

- Use native Hungarian search terms for best results: "laptop", "telefon" (phone), "butor" (furniture), "auto" (car), "kerekpar" (bicycle), "lakas" (apartment).
- Location filtering uses Hungarian city names: "budapest", "debrecen", "szeged", "miskolc", "pecs", "gyor".
- Residential proxies with Hungarian IP (HU) are recommended for reliable scraping.
- Each page returns ~20 listings. For 200 listings, the scraper paginate through 10 pages.
- Price filters use HUF. Common ranges: electronics 10,000-500,000 HUF, vehicles 500,000-10,000,000 HUF.

### Available categories

| Slug | Hungarian Name | English Translation |
|------|---------------|-------------------|
| `allatok` | Allatok | Animals |
| `auto-motor-jarmu` | Auto-Motor-Jarmu | Cars & Vehicles |
| `elektronika` | Elektronika | Electronics |
| `haztartas-butor` | Haztartas-Butor | Household & Furniture |
| `ingatlan` | Ingatlan | Real Estate |
| `muszaki-cikk` | Muszaki Cikk | Appliances |
| `otthon-kert` | Otthon-Kert | Home & Garden |
| `ruhazat-cipok` | Ruhazat-Cipok | Clothing & Shoes |
| `sport-szabadido` | Sport-Szabadido | Sports & Leisure |
| `szolgaltatas` | Szolgaltatas | Services |
| `munka` | Munka | Jobs |
| `gyerek` | Gyerek | Kids |
| `hobby` | Hobby | Hobby |
| `uzlet` | Uzlet | Business |

### Output

Here is realistic example output from Jofogas.hu:

```json
[
  {
    "itemTitle": "Lenovo ThinkPad T14 Gen 3 - 16GB RAM, 512GB SSD",
    "price": 185000,
    "currency": "HUF",
    "category": "Elektronika",
    "location": "Budapest",
    "condition": "used",
    "sellerName": "Kovacs Peter",
    "sellerType": "private",
    "postedDate": "2026-06-08",
    "imageUrl": "https://img.jofogas.hu/images/Lenovo_ThinkPad_T14_12345678.jpg",
    "url": "https://www.jofogas.hu/budapest/Lenovo_ThinkPad_T14_Gen_3_12345678.htm",
    "scrapedAt": "2026-06-09T10:30:15.000Z"
  },
  {
    "itemTitle": "iPhone 15 Pro 256GB - garanciális",
    "price": 420000,
    "currency": "HUF",
    "category": "Elektronika",
    "location": "Debrecen",
    "condition": "used",
    "sellerName": "Nagy Anna",
    "sellerType": "private",
    "postedDate": "2026-06-07",
    "imageUrl": "https://img.jofogas.hu/images/iPhone_15_Pro_87654321.jpg",
    "url": "https://www.jofogas.hu/debrecen/iPhone_15_Pro_256GB_87654321.htm",
    "scrapedAt": "2026-06-09T10:30:18.000Z"
  },
  {
    "itemTitle": "IKEA Billy konyvespolc - feher",
    "price": 15000,
    "currency": "HUF",
    "category": "Haztartas-Butor",
    "location": "Szeged",
    "condition": null,
    "sellerName": "Szabo Istvan",
    "sellerType": "private",
    "postedDate": "2026-06-06",
    "imageUrl": "https://img.jofogas.hu/images/IKEA_Billy_konyvespolc_11223344.jpg",
    "url": "https://www.jofogas.hu/szeged/IKEA_Billy_konyvespolc_feher_11223344.htm",
    "scrapedAt": "2026-06-09T10:30:21.000Z"
  }
]
````

### How much does it cost?

Jofogas Scraper uses PlaywrightCrawler (browser-based) which is more expensive than HTTP-only scrapers but necessary for reliable extraction from this site.

| Scenario | Listings | Estimated cost | Time |
|----------|----------|---------------|------|
| Quick search | 20 | ~$0.05 | ~30 sec |
| Standard search | 50 | ~$0.10 | ~1 min |
| Large search | 200 | ~$0.35 | ~5 min |
| Category sweep | 500 | ~$0.80 | ~12 min |
| Bulk extraction | 2,000 | ~$3.00 | ~45 min |

### Can I integrate?

Jofogas Scraper connects to the full Apify integration ecosystem:

- **Apify API** — Trigger runs programmatically, stream results in real-time
- **Webhooks** — Notify your systems when scraping completes
- **Google Sheets** — Auto-export Jofogas listings for team review
- **Zapier / Make** — Build no-code automations triggered by new listings
- **Slack alerts** — Get notified when specific items appear at target prices
- **Scheduled runs** — Set up daily monitoring with Apify Schedules
- **Direct download** — CSV, JSON, XML, or Excel export from the Apify Console

### Can I use it as an API?

Use Jofogas Scraper as a Hungarian classifieds API. Start runs, poll for results, and process data in your application.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/jofogas-scraper").call(run_input={
    "searchQuery": "laptop",
    "location": "budapest",
    "maxResults": 50,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    price = item.get("price", "N/A")
    print(f"{item['itemTitle']} - {price} HUF ({item.get('location', '')})")
```

#### JavaScript

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/jofogas-scraper").call({
  searchQuery: "auto",
  location: "budapest",
  maxResults: 200,
  priceTo: 5000000,
});

const { items } = await client
  .dataset(run.defaultDatasetId)
  .listItems();

items.forEach((item) => {
  console.log(`${item.itemTitle} - ${item.price} HUF (${item.location})`);
});
```

### FAQ

#### What is Jofogas.hu?

Jofogas.hu is Hungary's largest general classifieds platform, owned by Adevinta (formerly Schibsted). It is the Hungarian equivalent of Craigslist, Marktplaats, or Leboncoin. Millions of Hungarians use it daily to buy and sell used goods across every category imaginable.

#### What categories are available?

Jofogas covers 14+ main categories: Electronics, Vehicles, Real Estate, Household & Furniture, Clothing, Sports & Leisure, Home & Garden, Animals, Services, Jobs, Kids, Hobby, Appliances, and Business. Each category has dozens of subcategories.

#### What does "Megegyezes szerint" mean for price?

"Megegyezes szerint" means "by agreement" or "negotiable" — the seller hasn't listed a fixed price. These listings return `null` for the price field. "Ingyen" means free (price = 0).

#### Can I filter by location?

Yes, use the `location` parameter with Hungarian city names. Major cities supported: Budapest, Debrecen, Szeged, Miskolc, Pecs, Gyor, Nyiregyhaza, Kecskemet, Szekesfehervar, and many more. Leave empty to search all of Hungary.

#### Does this scraper handle anti-bot protection?

Jofogas has moderate anti-bot measures. The scraper uses Playwright (real browser) with fingerprint randomization and Hungarian residential proxies to ensure reliable access. For large-volume runs, the built-in retry mechanism handles temporary blocks.

### Limitations

- **Phone numbers** — Seller phone numbers are hidden behind a click-to-reveal button and are not extracted.
- **Full descriptions** — Search result pages show truncated descriptions. For full text, individual listing pages would need to be visited.
- **Expired listings** — Only currently active listings are returned. Jofogas removes expired ads.
- **Rate limiting** — Very aggressive scraping (5,000+ listings) may trigger temporary blocks. Use moderate concurrency and residential proxies.
- **Real estate and vehicles** — These categories have dedicated subdomains (ingatlan.jofogas.hu, auto.jofogas.hu) with different page structures. This scraper covers the main site categories.

### Other European classifieds scrapers

Build a complete view of European secondhand markets:

- **[Bazos Scraper](https://apify.com/studio-amba/bazos-scraper)** — Czech Republic and Slovakia
- **[2dehands Scraper](https://apify.com/studio-amba/2dehands-scraper)** — Belgium and Netherlands
- **[OLX Scraper](https://apify.com/studio-amba/olx-scraper)** — Poland
- **[Willhaben Scraper](https://apify.com/studio-amba/willhaben-scraper)** — Austria
- Check the [Apify Store](https://apify.com/store) for more European classifieds scrapers from Studio AMBA.

### Your feedback

If you notice any data quality issues, missing fields, or broken runs, let us know through the Apify Console. We actively monitor and update this scraper to ensure reliable operation on Jofogas.hu.

# Actor input Schema

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

Search keyword in Hungarian. Examples: "laptop", "iPhone", "butor" (furniture), "auto" (car), "kerekpar" (bicycle), "lakás" (apartment).

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

Filter by category. Leave empty to search all categories.

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

Filter by location. Use city names like "budapest", "debrecen", "szeged", "miskolc", "pecs", "gyor". Default: all of Hungary (magyarorszag).

## `priceFrom` (type: `integer`):

Minimum price filter in Hungarian Forints (HUF).

## `priceTo` (type: `integer`):

Maximum price filter in Hungarian Forints (HUF).

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

Maximum number of listings to scrape. Each page has ~20 listings.

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

Proxy settings. Jofogas has moderate anti-bot protection — residential proxies with Hungarian IP are recommended.

## Actor input object example

```json
{
  "searchQuery": "laptop",
  "category": "",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "HU"
  }
}
```

# 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 = {
    "searchQuery": "laptop",
    "location": "",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "HU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/jofogas-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 = {
    "searchQuery": "laptop",
    "location": "",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "HU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/jofogas-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 '{
  "searchQuery": "laptop",
  "location": "",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "HU"
  }
}' |
apify call studio-amba/jofogas-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jofogas Scraper - Hungarian Classifieds Data",
        "description": "Scrape classified listings from Jofogas.hu, Hungary's largest marketplace. Extract prices, seller info, images, location, and category data. No login required.",
        "version": "0.1",
        "x-build-id": "9oj8mqX1eexzDCsOd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~jofogas-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-jofogas-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/studio-amba~jofogas-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-jofogas-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/studio-amba~jofogas-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-jofogas-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search keyword in Hungarian. Examples: \"laptop\", \"iPhone\", \"butor\" (furniture), \"auto\" (car), \"kerekpar\" (bicycle), \"lakás\" (apartment)."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "allatok",
                            "auto-motor-jarmu",
                            "elektronika",
                            "haztartas-butor",
                            "ingatlan",
                            "muszaki-cikk",
                            "otthon-kert",
                            "ruhazat-cipok",
                            "sport-szabadido",
                            "szolgaltatas",
                            "munka",
                            "gyerek",
                            "hobby",
                            "uzlet"
                        ],
                        "type": "string",
                        "description": "Filter by category. Leave empty to search all categories.",
                        "default": ""
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filter by location. Use city names like \"budapest\", \"debrecen\", \"szeged\", \"miskolc\", \"pecs\", \"gyor\". Default: all of Hungary (magyarorszag)."
                    },
                    "priceFrom": {
                        "title": "Minimum Price (HUF)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price filter in Hungarian Forints (HUF)."
                    },
                    "priceTo": {
                        "title": "Maximum Price (HUF)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price filter in Hungarian Forints (HUF)."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape. Each page has ~20 listings.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Jofogas has moderate anti-bot protection — residential proxies with Hungarian IP are recommended."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
