# ZAP Imóveis Scraper - Brazil Real Estate Data (`memo23/zapimoveis-scraper`) Actor

Scrape ZAP Imoveis (Brazil) property listings, sale or rental. One row per property: price, condo fee, IPTU, area, bedrooms, bathrooms, parking, amenities, full address with lat/lon, advertiser and photos. Search by city or paste ZAP URLs. JSON/CSV out.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## ZAP Imóveis Scraper 🇧🇷🏡

Extract property listings from **[ZAP Imóveis](https://www.zapimoveis.com.br)** — one of Brazil's largest real-estate portals — at scale. Search any city, neighbourhood or state (sale **or** rental) and get one clean row per property: price, condo fee, IPTU, area, rooms, parking, amenities, a fully geocoded address, the advertiser, and every photo.

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

---

### Why use this scraper?

- **Straight from the source API.** It reads ZAP's own listings API, so each row already carries ~40 structured fields — no brittle HTML scraping, no missing prices.
- **Sale and rental.** Toggle `business` between `SALE` (venda) and `RENTAL` (aluguel).
- **Search by name — no ID hunting.** Type "São Paulo", "Copacabana" or "Belo Horizonte" and the actor resolves it through ZAP's own location autocomplete.
- **Or just paste URLs.** Drop in any ZAP search-results URL or a property-detail URL and it figures out the rest.
- **Rich, flat rows.** Price, condo fee (condomínio), IPTU, usable area, bedrooms, bathrooms, suites, parking, amenities, latitude/longitude, advertiser license and photos — ready for JSON, CSV or Excel.
- **Built-in Brazil residential proxy.** No proxy setup — the actor ships with a Brazil-geolocated residential pool at no extra cost.

---

### What it collects

Each property becomes one row with, among others:

| Group | Fields |
|-------|--------|
| Identity | `listingId`, `url`, `title`, `description` |
| Deal | `businessType`, `listingType`, `price`, `currency`, `monthlyCondoFee`, `yearlyIptu`, `pricePerArea` |
| Property | `unitType`, `propertyType`, `usageType`, `bedrooms`, `bathrooms`, `suites`, `parkingSpaces`, `usableArea`, `totalArea`, `amenities` |
| Address | `fullAddress`, `street`, `streetNumber`, `neighborhood`, `zone`, `city`, `state`, `stateAcronym`, `zipCode`, `latitude`, `longitude`, `locationId` |
| Advertiser | `advertiserName`, `advertiserId`, `advertiserLicense`, `advertiserWebsite`, `advertiserLogo`, `advertiserPhones`, `advertiserTier` |
| Media & meta | `images[]`, `createdAt`, `updatedAt`, `sourceUrl`, `scrapedAt` |

---

### Input

| Field | Type | Description |
|-------|------|-------------|
| `searchLocations` | array | City / neighbourhood names, e.g. `["São Paulo", "Copacabana"]`. |
| `business` | enum | `SALE` (venda) or `RENTAL` (aluguel). Applies to `searchLocations`. |
| `unitTypes` | array | Filter by `APARTMENT`, `HOME`, `CONDOMINIUM`, `ALLOTMENT_LAND`, `COMMERCIAL_PROPERTY`, `FARM`. Empty = all. |
| `minPrice` / `maxPrice` | integer | Price range in BRL. |
| `minBedrooms` | integer | Minimum bedrooms. |
| `startUrls` | array | ZAP search-result URLs and/or property-detail URLs. Auto-classified. |
| `maxItems` | integer | Hard cap on total rows (default 1000). |
| `maxItemsPerSearch` | integer | Cap per location / URL (default 1000). |
| `proxy` / `customProxyUrls` | object / array | Optional overrides — must be Brazil IPs. |

#### Example input

```json
{
  "searchLocations": ["São Paulo"],
  "business": "SALE",
  "unitTypes": ["APARTMENT"],
  "minPrice": 200000,
  "maxPrice": 900000,
  "maxItems": 500
}
````

Or by URL:

```json
{
  "startUrls": [
    "https://www.zapimoveis.com.br/venda/apartamentos/sp+sao-paulo/",
    "https://www.zapimoveis.com.br/aluguel/casas/rj+rio-de-janeiro/"
  ],
  "maxItems": 1000
}
```

***

### How it works

1. **Resolve the location.** Each city/neighbourhood (or the location in a pasted URL) is looked up through ZAP's location autocomplete to get its internal `locationId`.
2. **Page the listings API.** The actor requests the results in pages, combining your `business`, `unitTypes` and price/bedroom filters, from a clean Brazil residential IP.
3. **Flatten every property.** Each listing's price block, unit facts, amenities, geocoded address, advertiser and media are flattened into one row and pushed to the dataset.

***

### Output sample

```json
{
  "listingId": "2878107686",
  "url": "https://www.zapimoveis.com.br/imovel/venda-apartamento-2-quartos-com-piscina-jardim-dom-jose-zona-sul-sao-paulo-sp-47m2-id-2878107686/",
  "title": "Apartamento com 2 Quartos à venda, 47m²",
  "businessType": "SALE",
  "unitType": "APARTMENT",
  "price": 255000,
  "currency": "BRL",
  "monthlyCondoFee": 386,
  "yearlyIptu": null,
  "pricePerArea": 5425.53,
  "bedrooms": 2,
  "bathrooms": 1,
  "parkingSpaces": 1,
  "usableArea": 47,
  "amenities": ["BARBECUE_GRILL", "PARTY_HALL", "PLAYGROUND", "POOL", "GATED_COMMUNITY"],
  "neighborhood": "Jardim Dom José",
  "zone": "Zona Sul",
  "city": "São Paulo",
  "stateAcronym": "SP",
  "zipCode": "05886120",
  "latitude": -23.679127,
  "longitude": -46.789879,
  "advertiserName": "Brasiliano Imóveis",
  "advertiserLicense": "039729-J-SP",
  "advertiserTier": "gold",
  "images": ["https://resizedimgs.zapimoveis.com.br/img/vr-listing/59bd51a4.../foto.jpg?action=fit-in&dimension=870x653"],
  "createdAt": "2026-03-30T17:19:44.713Z",
  "sourceMode": "search"
}
```

***

### Common use cases

- **Market analysis** — track average price/m², condo fees and inventory by neighbourhood.
- **Lead generation** — build lists of advertisers (imobiliárias) with their license and contact.
- **Investment sourcing** — filter by price, area and amenities across cities in one run.
- **Price monitoring** — re-run on a schedule and diff `price` / `updatedAt` over time.

***

### FAQ

**Is this legal?** The actor collects only publicly available listing data. You are responsible for using the output in line with ZAP Imóveis' terms and applicable laws (including LGPD for any personal data).

**Do I need my own proxy?** No. A Brazil residential proxy is built in. You can supply your own under `customProxyUrls`, but it must be a Brazil IP — ZAP returns 403 to non-Brazil addresses.

**Sale or rental?** Both. Set `business` to `SALE` or `RENTAL`, or paste `/venda/…` or `/aluguel/…` URLs.

**Does it work for VivaReal too?** VivaReal shares the same platform and data model, so the same architecture applies — this actor targets ZAP Imóveis.

**How many results can I get?** As many as the search returns; use `maxItems` and `maxItemsPerSearch` to cap a run.

***

### Support

Found a missing field or a listing that didn't parse? Open an issue on the actor's **Issues** tab with the input you used — fixes are usually quick.

### ⚠️ Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or connected to** ZAP Imóveis, Grupo ZAP or OLX Brasil. All trademarks and listing content belong to their respective owners. It extracts only publicly accessible information. You are solely responsible for how you use the collected data and for complying with ZAP Imóveis' Terms of Service, the Brazilian LGPD, and any other applicable laws and regulations.

### SEO Keywords

ZAP Imóveis scraper, ZapImoveis scraper, Brazil real estate scraper, Brazil property scraper, scrape ZAP Imóveis, imóveis à venda scraper, aluguel de imóveis Brasil, Brazil real estate data, property listings Brazil API, São Paulo real estate scraper, Rio de Janeiro property data, real estate lead generation Brazil, imobiliária data extraction, Grupo ZAP scraper, VivaReal alternative scraper, apartamentos à venda dados, casas para alugar scraper.

# Actor input Schema

## `searchLocations` (type: `array`):

City or neighbourhood names, e.g. `São Paulo`, `Rio de Janeiro`, `Copacabana`, `Belo Horizonte`. Each is resolved through ZAP's own location autocomplete, then combined with the Business / Property types / price filters below.

## `business` (type: `string`):

Sale (venda) or rental (aluguel) — applies to the locations above.

## `unitTypes` (type: `array`):

Filter the location searches by property type. Leave empty for all types.

## `minPrice` (type: `integer`):

Minimum price in reais for the location searches.

## `maxPrice` (type: `integer`):

Maximum price in reais for the location searches.

## `minBedrooms` (type: `integer`):

Minimum number of bedrooms for the location searches.

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

Paste ZAP Imoveis URLs — search-result pages (`https://www.zapimoveis.com.br/venda/apartamentos/sp+sao-paulo/`) and/or property-detail pages (`https://www.zapimoveis.com.br/imovel/...-id-2878107686/`). Auto-classified.

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

For pasted property-detail URLs, parse the page's structured data. Search results already return ~40 fields per property from the API, so you rarely need this. Default off.

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

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

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

Cap per location / search URL. The API returns 100 properties per page. Default 1000.

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

Parallel HTTP requests. Default 6.

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

Per-request retry budget on 403 / 429 / 5xx and network errors. Each retry rotates to a fresh Brazil residential IP. Default 12.

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

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

## `customProxyUrls` (type: `array`):

Optional — bring your own HTTP proxy (e.g. `http://user:pass@host:port`). When set, these are used instead of Apify Proxy on any plan; the scraper rotates the session per request. Must be Brazil IPs that work from Apify's cloud egress — ZAP returns 403 to non-Brazil addresses.

## Actor input object example

```json
{
  "searchLocations": [
    "São Paulo"
  ],
  "business": "SALE",
  "unitTypes": [],
  "startUrls": [],
  "scrapeDetails": false,
  "maxItems": 1000,
  "maxItemsPerSearch": 1000,
  "maxConcurrency": 6,
  "maxRequestRetries": 12,
  "customProxyUrls": []
}
```

# 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 = {
    "searchLocations": [
        "São Paulo"
    ],
    "startUrls": [],
    "customProxyUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/zapimoveis-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 = {
    "searchLocations": ["São Paulo"],
    "startUrls": [],
    "customProxyUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/zapimoveis-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 '{
  "searchLocations": [
    "São Paulo"
  ],
  "startUrls": [],
  "customProxyUrls": []
}' |
apify call memo23/zapimoveis-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ZAP Imóveis Scraper - Brazil Real Estate Data",
        "description": "Scrape ZAP Imoveis (Brazil) property listings, sale or rental. One row per property: price, condo fee, IPTU, area, bedrooms, bathrooms, parking, amenities, full address with lat/lon, advertiser and photos. Search by city or paste ZAP URLs. JSON/CSV out.",
        "version": "0.1",
        "x-build-id": "C4c3Ppzm4KZzq2AqW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~zapimoveis-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-zapimoveis-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/memo23~zapimoveis-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-zapimoveis-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/memo23~zapimoveis-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-zapimoveis-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": {
                    "searchLocations": {
                        "title": "Locations to search",
                        "type": "array",
                        "description": "City or neighbourhood names, e.g. `São Paulo`, `Rio de Janeiro`, `Copacabana`, `Belo Horizonte`. Each is resolved through ZAP's own location autocomplete, then combined with the Business / Property types / price filters below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "business": {
                        "title": "Business",
                        "enum": [
                            "SALE",
                            "RENTAL"
                        ],
                        "type": "string",
                        "description": "Sale (venda) or rental (aluguel) — applies to the locations above.",
                        "default": "SALE"
                    },
                    "unitTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Filter the location searches by property type. Leave empty for all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "APARTMENT",
                                "HOME",
                                "CONDOMINIUM",
                                "ALLOTMENT_LAND",
                                "COMMERCIAL_PROPERTY",
                                "FARM"
                            ],
                            "enumTitles": [
                                "Apartment",
                                "House",
                                "House in condominium",
                                "Land / lot",
                                "Commercial",
                                "Farm / country"
                            ]
                        },
                        "default": []
                    },
                    "minPrice": {
                        "title": "Min price (BRL)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in reais for the location searches."
                    },
                    "maxPrice": {
                        "title": "Max price (BRL)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in reais for the location searches."
                    },
                    "minBedrooms": {
                        "title": "Min bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of bedrooms for the location searches."
                    },
                    "startUrls": {
                        "title": "ZAP URLs (search or property)",
                        "type": "array",
                        "description": "Paste ZAP Imoveis URLs — search-result pages (`https://www.zapimoveis.com.br/venda/apartamentos/sp+sao-paulo/`) and/or property-detail pages (`https://www.zapimoveis.com.br/imovel/...-id-2878107686/`). Auto-classified.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeDetails": {
                        "title": "Scrape property detail pages",
                        "type": "boolean",
                        "description": "For pasted property-detail URLs, parse the page's structured data. Search results already return ~40 fields per property from the API, so you rarely need this. Default off.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max results (whole run)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on rows across the entire run. Each row is one paid `property` event. Default 1000. Free-tier users are additionally capped at 100.",
                        "default": 1000
                    },
                    "maxItemsPerSearch": {
                        "title": "Max properties per location",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap per location / search URL. The API returns 100 properties per page. Default 1000.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max parallel requests",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Parallel HTTP requests. Default 6.",
                        "default": 6
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per-request retry budget on 403 / 429 / 5xx and network errors. Each retry rotates to a fresh Brazil residential IP. Default 12.",
                        "default": 12
                    },
                    "proxy": {
                        "title": "Proxy configuration (optional override)",
                        "type": "object",
                        "description": "Leave empty — the actor already routes all traffic through its own built-in Brazil residential proxy at no extra cost to you. Only set this if you want to use your own proxies (must be Brazil IPs)."
                    },
                    "customProxyUrls": {
                        "title": "Custom proxy URLs (advanced)",
                        "type": "array",
                        "description": "Optional — bring your own HTTP proxy (e.g. `http://user:pass@host:port`). When set, these are used instead of Apify Proxy on any plan; the scraper rotates the session per request. Must be Brazil IPs that work from Apify's cloud egress — ZAP returns 403 to non-Brazil addresses.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
