# Pincali.com \[$1.5💰] Mexico Real Estate · Sale & Rent · GPS (`memo23/pincali-scraper`) Actor

Scrape Pincali.com Mexican real-estate listings — price, price/m², bedrooms, bathrooms, parking, lot & construction size, GPS coordinates, full photo gallery, amenities and the publishing agency. Sale & rent, any city. Paste a search or property URL, or build one from filters

- **URL**: https://apify.com/memo23/pincali-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

from $1.40 / 1,000 results

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

## Pincali.com Scraper

Turn any [Pincali.com](https://www.pincali.com) search into structured Mexican real-estate data. Paste a search/listing URL or a direct property URL — or just pick a property type, operation and city — and get one clean row per listing with price, price/m², GPS coordinates, the full photo gallery, amenities, and the publishing agency.

Built for **sale and rent** listings across all of Mexico: houses, apartments, gated communities, lots, offices, commercial and industrial space.

#### How it works

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

#### ✨ Why use this scraper?

- **Two ways in** — paste any Pincali URL (search page or property page, English or Spanish), *or* build a search from filters (operation × property type × city/state). No need to hand-craft slugs.
- **40+ fields per property** — price, currency, computed **price per m²**, bedrooms, bathrooms, half-baths, parking, construction + lot size, year built, maintenance fee, amenities, financing, full description, agency, and bilingual URLs.
- **Real GPS coordinates** — exact `latitude`/`longitude` pulled from each property's map, ready to drop on a map or join to other geodata.
- **Full photo gallery** — every statically-served EasyBroker image for the property, at original resolution, with the "similar properties" thumbnails filtered out.
- **Auto-pagination at scale** — one listing URL walks every `?page=N` for you (Pincali has 100k+ listings); a `maxItems` cap keeps billing predictable.
- **Deduped & normalized** — one row per property, deduped by EasyBroker `publicId`, with `operation` normalized to `sale`/`rent` and numbers as real numbers.

#### 🎯 Use cases

| Audience | What they pull |
|---|---|
| **Real-estate investors** | Asking prices + price/m² by neighborhood, city and state to spot mispriced inventory |
| **Market analysts** | Inventory, pricing and feature trends across Mexican metros over time |
| **Brokers & agencies** | Competitive listing intelligence + a directory of publishing agencies |
| **PropTech & portals** | Structured listing feeds to seed search, valuation or recommendation models |
| **Lead-gen teams** | Publishing-agency names (+ optional contact-email enrichment) for outreach |
| **Researchers / data scientists** | Clean, geocoded housing datasets for econometric and ML work |

#### 📥 Supported inputs

| Input | Example | Behaviour |
|---|---|---|
| Search / listing URL | `https://www.pincali.com/en/properties/houses-for-sale` | Auto-paginates and scrapes every property |
| Location listing URL | `https://www.pincali.com/en/properties/apartments-for-rent-in-merida-yucatan` | Same, scoped to a city/state |
| Direct property URL | `https://www.pincali.com/en/home/{slug}` | Scrapes that single property |
| Spanish property URL | `https://www.pincali.com/inmueble/{slug}` | Also supported and classified |
| Filter builder | operation = `for-rent`, property type = `apartments`, location = `Mérida, Yucatán` | Builds the search URL for you |

**Not supported:** authenticated/account pages, saved-search feeds, price/bedroom *query* filters (Pincali applies those client-side, so they aren't URL-addressable — scrape broadly and filter in your own pipeline).

#### 🔄 How it works

1. **Classify** every input URL as a search/listing page or a direct property page.
2. **Walk pagination** — for listing URLs, follow `?page=N` (42 cards per page) until `maxItems` is reached or the results run out.
3. **Fetch & parse** each property page: the `RealEstateListing` JSON-LD for core fields, plus the on-page `.listing__*` blocks for everything else (coordinates, gallery, amenities, parking, lot size, agency).
4. **Normalize & dedup** — coerce numbers, normalize `operation`, compute `pricePerM2`, and drop duplicate properties by EasyBroker `publicId`.
5. **(Optional) enrich** the publishing agency with a discovered website + contact email.
6. **Push** one merged row per property to the dataset (JSON / CSV / Excel).

#### ⚙️ Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | `["…/houses-for-sale"]` | Pincali search/listing and/or property URLs. Mix freely. |
| `operation` | select | — | `for-sale` / `for-rent` / `under-construction` (filter builder). |
| `propertyType` | select | — | `houses`, `apartments`, `lots`, `offices`, … or `properties` (any). |
| `location` | string | — | Free-text city/state — accents OK (e.g. `Mérida, Yucatán`). Slugified for you. |
| `enrichEmails` | boolean | `false` | Discover a contact email for each agency. Best-effort and free (you only pay the per-result price). |
| `maxItems` | integer | `1000` | Hard cap on properties scraped (controls billing). |
| `maxConcurrency` | integer | `10` | Max property pages fetched in parallel. |
| `proxy` | object | Apify proxy | Proxy config. Pincali has no anti-bot — the default (or none) works. |

> Leave the filter-builder fields empty to use `startUrls`. Set any one of them and the actor builds the search URL (sensible defaults fill the rest).

#### 📊 Output overview

Each dataset row is a single property. Core listing facts (title, price, type, beds/baths, address, coordinates) come from the page's `RealEstateListing` JSON-LD; everything Pincali renders only in the DOM (parking, lot size, year built, maintenance fee, amenities, the photo gallery, and the publishing agency) is parsed and merged into the same row. Numbers are real numbers, `operation` is normalized to `sale`/`rent`, and `pricePerM2` is computed for you.

#### 📦 Output sample

```json
{
  "type": "property",
  "propertyId": "6079233",
  "publicId": "EB-WI9233",
  "propertyUrl": "https://www.pincali.com/en/home/casas-en-pre-venta-en-fracc-privada-cipres",
  "spanishUrl": "https://www.pincali.com/inmueble/casas-en-pre-venta-en-fracc-privada-cipres",
  "title": "CASAS EN PRE-VENTA EN FRACC. PRIVADA CIPRÉS",
  "operation": "sale",
  "propertyType": "House",
  "price": 2300000,
  "currency": "MXN",
  "priceFormatted": "$2,300,000 MXN",
  "pricePerM2": 15043,
  "bedrooms": 3,
  "bathrooms": 2,
  "halfBaths": 1,
  "parkingSpaces": 2,
  "constructionSize": 152.9,
  "lotSize": 112.66,
  "amenities": ["Cistern", "Street parking", "Kitchen", "Double story"],
  "city": "Durango",
  "state": "Durango",
  "postalCode": "34217",
  "country": "MX",
  "coordinates": { "latitude": 24.0511367557, "longitude": -104.6515890791 },
  "coverImage": "https://assets.easybroker.com/property_images/6079233/107591534/EB-WI9233.jpg",
  "agencyName": "Melero Bienes Raices",
  "agencyId": "121518",
  "datePosted": "2026-06-27T06:58:01-06:00",
  "scrapedAt": "2026-06-27T13:11:50.612Z"
}
````

#### 🗂 Key output fields

| Category | Fields |
|---|---|
| **Identity** | `propertyId` (EasyBroker internal), `publicId` (`EB-…`), `slug`, `propertyUrl`, `canonicalUrl`, `spanishUrl` |
| **Classification** | `title`, `operation` (`sale`/`rent`/`other`), `propertyType`, `datePosted`, `availability` |
| **Pricing** | `price`, `currency`, `priceFormatted`, `pricePerM2`, `maintenanceFee` |
| **Specs** | `bedrooms`, `bathrooms`, `halfBaths`, `parkingSpaces`, `constructionSize` (m²), `lotSize` (m²), `yearBuilt` |
| **Description** | `shortDescription`, `description` (full), `amenities` (flat), `amenityGroups` (categorized), `financingOptions` |
| **Location** | `address`, `neighborhood`, `city`, `state`, `postalCode`, `country`, `coordinates {latitude, longitude}` |
| **Media** | `coverImage`, `images[]` (original-resolution gallery) |
| **Agency** | `agencyName`, `agencyId`, `agencyLogo` |
| **Enrichment** *(opt-in)* | `contactEmail`, `contactWebsite`, `emailEnrichment` |

#### ❓ FAQ

**Does it scrape both for-sale and for-rent listings?**
Yes. Operation is taken from the listing and normalized to `sale` / `rent`. Use the `for-rent` filter or a `…-for-rent…` URL for rentals.

**Can I scrape a whole city or state?**
Yes — use a location listing URL (e.g. `/en/properties/houses-for-sale-in-merida-yucatan`) or set the `location` filter. The actor paginates through every result up to `maxItems`.

**Are GPS coordinates always included?**
For the vast majority of listings, yes — exact coordinates when the agent dropped a pin, area-level coordinates otherwise. A small number of listings have no map at all, in which case `coordinates` is `null`.

**How many photos do I get?**
The complete gallery that Pincali serves in the page HTML — typically 10–30 images at original resolution. A few listings render only their cover photo server-side; those return just `coverImage`.

**Do I get the agent's phone or email?**
The publishing **agency name** (and logo) is always captured. Pincali hides the agent's direct phone/email behind a contact form, so they aren't on the page — enable `enrichEmails` to *discover* an agency email best-effort (free; you only pay the per-result price).

**Do I need a proxy?**
No. Pincali has no anti-bot protection, so the default automatic proxy — or no proxy — works fine. Residential is only worth it for very large runs.

#### 💬 Support

Found a bug or need an extra field? Open an issue from the actor's **Issues** tab on the Apify Console and it'll be looked at quickly.

#### 🛠 Additional services

Need a custom real-estate or directory scraper, scheduled runs, or a push integration into your own database / sheet / webhook? Get in touch through Apify — bespoke builds and modifications are welcome.

#### 🔎 Explore more scrapers

Looking for other listing-site scrapers (real estate, jobs, products, local businesses)? Browse the rest of the publisher's actors on the Apify Store.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Pincali, EasyBroker, or any of their subsidiaries or affiliates. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available property-listing pages — no authenticated endpoints, account-only features, or content behind a Pincali login. Users are responsible for ensuring their use complies with Pincali's Terms of Service, applicable data-protection law (LFPDPPP, GDPR, CCPA, etc.), and any contractual obligations of their own organisation. Personal data (such as agent or agency contact details) must be handled lawfully.

***

### SEO Keywords

pincali scraper, scrape pincali, pincali.com scraper, pincali api, apify pincali, mexico real estate scraper, mexican property scraper, easybroker scraper, real estate data mexico, property listings mexico, casas en venta scraper, departamentos en renta scraper, real estate price data, property market scraper, inmuebles mexico scraper, mexico housing data, real estate lead generation, property gps coordinates scraper, pincali alternative scraper, real estate listing api

# Actor input Schema

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

Full pincali.com URLs to crawl. Listing URLs auto-paginate; property URLs are scraped directly.

## `operation` (type: `string`):

Transaction type to search for.

## `propertyType` (type: `string`):

Property category to search for. Choose 'Any type' to include every category.

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

Free-text Mexican city and/or state — accents and spaces are fine (e.g. 'Mérida, Yucatán', 'Ciudad de México', 'Monterrey Nuevo León'). It is slugified and appended to the search. Leave empty for nationwide.

## `enrichEmails` (type: `boolean`):

If enabled, tries to find a contact email for each publishing agency by discovering its website (Clearbit) and reading its contact/about pages. Adds contactEmail + contactWebsite columns plus a detailed emailEnrichment object. Best-effort and free in this version; agency emails are NOT on Pincali itself, so hit-rate varies (you're only charged the standard per-result price, never extra for enrichment).

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

Hard cap on the number of properties collected. Pincali listings have thousands of pages, so always set a sensible cap to control billing.

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

Maximum number of property pages processed in parallel.

## `minConcurrency` (type: `integer`):

Minimum number of property pages processed in parallel.

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

Number of retries before a failed request is given up.

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

Apify proxy settings. Pincali has no anti-bot, so the default automatic proxy (or even no proxy) works fine; residential is only worth it for very large runs.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.pincali.com/en/properties/houses-for-sale"
  ],
  "location": "Mérida, Yucatán",
  "enrichEmails": false,
  "maxItems": 1000,
  "maxConcurrency": 10,
  "minConcurrency": 1,
  "maxRequestRetries": 5,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.pincali.com/en/properties/houses-for-sale"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/pincali-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 = {
    "startUrls": ["https://www.pincali.com/en/properties/houses-for-sale"],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/pincali-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 '{
  "startUrls": [
    "https://www.pincali.com/en/properties/houses-for-sale"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call memo23/pincali-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pincali.com [$1.5💰] Mexico Real Estate · Sale & Rent · GPS",
        "description": "Scrape Pincali.com Mexican real-estate listings — price, price/m², bedrooms, bathrooms, parking, lot & construction size, GPS coordinates, full photo gallery, amenities and the publishing agency. Sale & rent, any city. Paste a search or property URL, or build one from filters",
        "version": "0.0",
        "x-build-id": "gIy3nIdsExYk0nlS8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~pincali-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-pincali-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~pincali-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-pincali-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~pincali-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-pincali-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Pincali URLs",
                        "type": "array",
                        "description": "Full pincali.com URLs to crawl. Listing URLs auto-paginate; property URLs are scraped directly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "operation": {
                        "title": "Operation",
                        "enum": [
                            "for-sale",
                            "for-rent",
                            "under-construction"
                        ],
                        "type": "string",
                        "description": "Transaction type to search for."
                    },
                    "propertyType": {
                        "title": "Property type",
                        "enum": [
                            "properties",
                            "houses",
                            "apartments",
                            "houses-in-gated-communities",
                            "lots",
                            "offices",
                            "commercial-storage-units",
                            "industrial-warehouses"
                        ],
                        "type": "string",
                        "description": "Property category to search for. Choose 'Any type' to include every category."
                    },
                    "location": {
                        "title": "Location (city and/or state)",
                        "type": "string",
                        "description": "Free-text Mexican city and/or state — accents and spaces are fine (e.g. 'Mérida, Yucatán', 'Ciudad de México', 'Monterrey Nuevo León'). It is slugified and appended to the search. Leave empty for nationwide."
                    },
                    "enrichEmails": {
                        "title": "Enrich with agency contact emails (experimental, free)",
                        "type": "boolean",
                        "description": "If enabled, tries to find a contact email for each publishing agency by discovering its website (Clearbit) and reading its contact/about pages. Adds contactEmail + contactWebsite columns plus a detailed emailEnrichment object. Best-effort and free in this version; agency emails are NOT on Pincali itself, so hit-rate varies (you're only charged the standard per-result price, never extra for enrichment).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum items to scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the number of properties collected. Pincali listings have thousands of pages, so always set a sensible cap to control billing.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of property pages processed in parallel.",
                        "default": 10
                    },
                    "minConcurrency": {
                        "title": "Min concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Minimum number of property pages processed in parallel.",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of retries before a failed request is given up.",
                        "default": 5
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Pincali has no anti-bot, so the default automatic proxy (or even no proxy) works fine; residential is only worth it for very large runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
