# Kyero Scraper — Property Listings, Coordinates & Agent Contacts (`haketa/kyero-scraper`) Actor

Scrape Kyero.com for Spanish and European properties for sale & rent. Extract price, coordinates, bedrooms, size, features, agent contacts, images and listing dates. Keyword search + URL modes. ES residential proxy for Cloudflare bypass.

- **URL**: https://apify.com/haketa/kyero-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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

## Kyero Scraper — European Property Listings, Coordinates & Agent Contacts

Scrape **Kyero.com**, the leading European property portal for international buyers, covering **Spain, Portugal, France, and Italy**. Extract properties for sale and rent with **price, GPS coordinates, bedrooms, size, features, agent contact details, images, and listing dates** — data that competing Kyero scrapers miss.

Unlike other Kyero actors that only parse HTML listing cards, this scraper visits each property detail page to extract **latitude/longitude coordinates, agent phone/email/website, full feature lists, and listing dates** — fields essential for serious real estate analysis that competitors leave empty.

**Spanish residential proxy required** — Kyero uses Cloudflare that geo-gates non-EU IPs. Included by default.

---

### ⚡ Quick Start

```json
{
    "country": "spain",
    "query": "barcelona",
    "maxItems": 50
}
````

👉 50 Barcelona properties with prices, coordinates, bedrooms, and agent contacts.

***

### 🌍 Countries

| Country | URL Pattern | Currency |
|---------|------------|----------|
| 🇪🇸 **Spain** | kyero.com/en/spain-property-for-sale | EUR (€) |
| 🇵🇹 **Portugal** | kyero.com/en/portugal-property-for-sale | EUR (€) |
| 🇫🇷 **France** | kyero.com/en/france-property-for-sale | EUR (€) |
| 🇮🇹 **Italy** | kyero.com/en/italy-property-for-sale | EUR (€) |

***

### Data Fields

| Category | Fields |
|----------|--------|
| **Identity** | `propertyId`, `title`, `url`, `referenceNo` |
| **Price** | `price` (numeric), `priceFormatted` (e.g. "€345,000") |
| **Property** | `propertyType`, `bedrooms`, `bathrooms`, `builtM2`, `plotM2` |
| **Location** | `address`, `latitude`, `longitude` ✅ |
| **Features** | `features` (JSON array: pool, terrace, lift, sea view...) |
| **Description** | `description` (full text) |
| **Media** | `images` (JSON array of URLs) |
| **Agent** | `agentName`, `agentPhone`, `agentEmail`, `agentWebsite` |
| **Dates** | `dateListed`, `scrapedAt` |
| **Listing** | `listingType` (for\_sale / to\_rent) |

***

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `country` | select | spain | Spain / Portugal / France / Italy |
| `listingType` | select | for\_sale | For Sale / To Rent |
| `query` | string | barcelona | Location keyword (barcelona, alicante, paris...) |
| `startUrls` | array | \[] | Kyero search or property URLs (overrides country/query) |
| `includeDetails` | boolean | true | Visit detail pages for coordinates, agent, features |
| `maxItems` | integer | 100 | Maximum properties (0 = no limit) |
| `maxPages` | integer | 5 | Search result pages |
| `requestDelay` | integer | 500 | Delay between detail requests (ms) |
| `maxConcurrency` | integer | 8 | Parallel detail page requests |
| `proxyConfiguration` | proxy | ES RESIDENTIAL | Required — Cloudflare geo-gating |

***

### Use Cases

- **Property investment analysis** — Coordinates enable map-based market analysis
- **Agent lead generation** — Phone + email from detail pages for B2B outreach
- **Market research** — Price/m² trends across Spanish regions
- **Relocation services** — Curated property lists for international buyers

***

### Integration

#### JavaScript

```javascript
const run = await client.actor('haketa/kyero-scraper').call({ country: 'spain', query: 'alicante', maxItems: 100 });
```

#### Python

```python
run = client.actor('haketa/kyero-scraper').call(run_input={'country': 'spain', 'query': 'alicante', 'maxItems': 100})
```

#### CLI

```bash
apify call haketa/kyero-scraper --input '{"country":"spain","query":"barcelona","maxItems":100}'
```

***

### FAQ

**Q: Why coordinates matter?**
A: Without lat/lng, you can't map properties, calculate distances to amenities, or do spatial market analysis. memo23 and other Kyero scrapers don't extract coordinates — we do.

**Q: Why ES residential proxy?**
A: Kyero uses Cloudflare which challenges non-EU IPs with "Just a moment..." pages. An ES residential proxy makes requests appear as Spanish household visitors.

**Q: Can I search for properties without a city?**
A: Yes — leave `query` empty to scrape all properties in the country. Use `maxItems` to control volume.

***

*The only Kyero scraper with GPS coordinates, agent contacts, and listing dates — data that real estate professionals actually need.*

***

### Performance & Cost

| Mode | Speed | Proxy |
|------|-------|-------|
| Search only (`includeDetails: false`) | ~20-30 props/sec | ES Residential |
| Search + details | ~5-10 props/sec | ES Residential |
| Direct URLs | ~5-10 props/sec | ES Residential |

**Typical cost**: 100 properties with full detail = ~60-90 seconds. ES residential proxy data transfer is the main cost driver.

***

### Example Output

```json
{
    "propertyId": "555123",
    "title": "Apartment in El Masnou, Barcelona province",
    "url": "https://www.kyero.com/en/property/555123",
    "price": "345000",
    "priceFormatted": "€345,000",
    "listingType": "for_sale",
    "bedrooms": "3",
    "bathrooms": "2",
    "builtM2": "120",
    "plotM2": null,
    "propertyType": "Apartment",
    "address": "El Masnou, Costa Garraf / Maresme, Barcelona province, Catalonia, Spain",
    "latitude": "41.4823",
    "longitude": "2.3178",
    "features": "[\"lift\",\"terrace\",\"pool\",\"sea_view\",\"parking\",\"air_conditioning\"]",
    "description": "Beautiful 3-bedroom apartment in El Masnou with sea views...",
    "images": "[\"https://images.kyero.com/.../1.jpg\",\"https://images.kyero.com/.../2.jpg\"]",
    "agentName": "Costa Barcelona Real Estate",
    "agentPhone": "+34 93 123 45 67",
    "agentEmail": "info@costabarcelona.com",
    "agentWebsite": "https://www.costabarcelona.com",
    "referenceNo": "CB-2024-0891",
    "dateListed": "2026-05-15",
    "scrapedAt": "2026-06-22T15:00:00.000Z"
}
```

***

### Anti-Bot Strategy

Kyero uses **Cloudflare** (not Akamai) for bot protection. Our approach:

- **Spanish residential IPs** via Apify's ES residential proxy pool
- **Browser TLS fingerprint** via got-scraping Chrome impersonation
- **Cloudflare challenge detection** — automatically retries with fresh proxy on "Just a moment..." pages
- **Moderate delays** — 500ms between requests with jitter
- **Adaptive retry** — up to 4 attempts per request, doubling backoff

***

### Common Search Queries

#### Spain (most listings)

```
barcelona, madrid, valencia, alicante, malaga, marbella, mallorca, ibiza, costa-blanca, costa-del-sol, murcia, sevilla, granada, cadiz
```

#### Portugal

```
lisbon, algarve, porto, albufeira, lagos, tavira, cascais, silver-coast, madeira
```

#### France

```
paris, nice, cannes, provence, alps, bordeaux, lyon, marseille, cote-dazur, languedoc
```

#### Italy

```
rome, milan, tuscany, florence, venice, lake-como, puglia, sardinia, sicily, umbria, naples
```

***

### Tips & Best Practices

- **Start with list-only**: `includeDetails: false` for a fast scan, then enrich interesting properties via `startUrls`
- **Narrow your query**: "barcelona" returns 10,000+ properties — add qualifiers like "barcelona-beachfront" or use price filters in `startUrls`
- **Monitor for Cloudflare blocks**: If you see "Cloudflare block" warnings, increase `requestDelay` to 1000ms
- **Cross-country comparison**: Run the same listing type across multiple countries to compare price/m²
- **Schedule for new listings**: Weekly runs with `maxPages: 1` to catch newly listed properties
- **Export coordinates**: Use the `latitude`/`longitude` fields to build property heatmaps in tools like Google Maps, Tableau, or Kepler.gl

***

### Data Quality Notes

| Field | Typical Fill Rate | Notes |
|-------|------------------|-------|
| `latitude` | 70-80% | From detail page embedded data |
| `longitude` | 70-80% | From detail page embedded data |
| `agentPhone` | 60-70% | From detail page tel: links |
| `agentEmail` | 40-50% | From detail page mailto: links |
| `agentWebsite` | 50-60% | Agency website when listed |
| `dateListed` | 30-40% | Not always shown on Kyero |
| `features` | 80-90% | Pool, terrace, lift, parking... |
| `builtM2` | 85-95% | Almost always available |
| `plotM2` | 30-40% | Only for houses/villas with land |

***

### Known Limitations

- **Pagination cap**: Kyero limits results to ~20-25 pages per search. Segment by location for larger datasets.
- **Coordinates on detail only**: Coordinates require detail page visit (`includeDetails: true`)
- **ES proxy required**: Without Spanish residential proxy, Cloudflare returns challenge pages
- **Agent contact varies**: Not all listings include agent phone/email — Kyero's page design varies by agency

***

### Legal & Responsible Use

This actor extracts publicly available property listings from Kyero.com. Users are responsible for complying with Kyero's Terms of Service and GDPR where applicable. Data is intended for legitimate real estate market research, investment analysis, and B2B agent outreach.

# Actor input Schema

## `country` (type: `string`):

Which Kyero country to scrape.

## `listingType` (type: `string`):

For sale or to rent.

## `query` (type: `string`):

Location keyword, e.g. 'barcelona', 'alicante', 'paris'. Leave empty to scrape all properties in the country.

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

Kyero search or property URLs. Required. Kyero uses location IDs in URLs — search on kyero.com, then paste the URL here. Example: 'https://www.kyero.com/en/spain-property-for-sale-0l55529'

## `includeDetails` (type: `boolean`):

Visit each property page for full description, GPS coordinates, all features, and agent contact details. Slower per property but much richer.

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

Maximum properties to scrape. 0 = no limit.

## `maxPages` (type: `integer`):

Maximum search result pages per URL. 0 = no limit.

## `requestDelay` (type: `integer`):

Delay between requests. 300-800ms recommended for Cloudflare.

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

Parallel detail page requests. Keep 6-10.

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

Spanish residential proxy REQUIRED — Kyero uses Cloudflare that geo-gates non-EU IPs. Preconfigured — don't change unless you have your own ES proxy.

## Actor input object example

```json
{
  "country": "spain",
  "listingType": "for_sale",
  "query": "barcelona",
  "startUrls": [
    "https://www.kyero.com/en/spain-property-for-sale-0l55529"
  ],
  "includeDetails": true,
  "maxItems": 50,
  "maxPages": 5,
  "requestDelay": 500,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "ES"
  }
}
```

# Actor output Schema

## `propertyId` (type: `string`):

Kyero property ID

## `title` (type: `string`):

Property title

## `url` (type: `string`):

Property page URL

## `price` (type: `string`):

Price in EUR

## `priceFormatted` (type: `string`):

Formatted price (e.g. €345,000)

## `listingType` (type: `string`):

for\_sale / to\_rent

## `bedrooms` (type: `string`):

Number of bedrooms

## `bathrooms` (type: `string`):

Number of bathrooms

## `builtM2` (type: `string`):

Built area in square meters

## `plotM2` (type: `string`):

Plot/land area in square meters

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

Apartment/Villa/Townhouse/Penthouse etc.

## `address` (type: `string`):

Full address

## `latitude` (type: `string`):

GPS latitude

## `longitude` (type: `string`):

GPS longitude

## `features` (type: `string`):

Property features (JSON array: pool, terrace, lift...)

## `description` (type: `string`):

Full property description

## `images` (type: `string`):

Property image URLs (JSON array)

## `agentName` (type: `string`):

Estate agent name

## `agentPhone` (type: `string`):

Agent phone number

## `agentEmail` (type: `string`):

Agent email address

## `agentWebsite` (type: `string`):

Agent website URL

## `referenceNo` (type: `string`):

Agency reference number

## `dateListed` (type: `string`):

Listing date

## `scrapedAt` (type: `string`):

ISO scrape timestamp

# 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 = {
    "country": "spain",
    "listingType": "for_sale",
    "query": "barcelona",
    "startUrls": [
        "https://www.kyero.com/en/spain-property-for-sale-0l55529"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "ES"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/kyero-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 = {
    "country": "spain",
    "listingType": "for_sale",
    "query": "barcelona",
    "startUrls": ["https://www.kyero.com/en/spain-property-for-sale-0l55529"],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "ES",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/kyero-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 '{
  "country": "spain",
  "listingType": "for_sale",
  "query": "barcelona",
  "startUrls": [
    "https://www.kyero.com/en/spain-property-for-sale-0l55529"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "ES"
  }
}' |
apify call haketa/kyero-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kyero Scraper — Property Listings, Coordinates & Agent Contacts",
        "description": "Scrape Kyero.com for Spanish and European properties for sale & rent. Extract price, coordinates, bedrooms, size, features, agent contacts, images and listing dates. Keyword search + URL modes. ES residential proxy for Cloudflare bypass.",
        "version": "0.1",
        "x-build-id": "cvHfs5XOBar3d6d55"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~kyero-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-kyero-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/haketa~kyero-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-kyero-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/haketa~kyero-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-kyero-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": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "spain",
                            "portugal",
                            "france",
                            "italy"
                        ],
                        "type": "string",
                        "description": "Which Kyero country to scrape.",
                        "default": "spain"
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "for_sale",
                            "to_rent"
                        ],
                        "type": "string",
                        "description": "For sale or to rent.",
                        "default": "for_sale"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Location keyword, e.g. 'barcelona', 'alicante', 'paris'. Leave empty to scrape all properties in the country."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Kyero search or property URLs. Required. Kyero uses location IDs in URLs — search on kyero.com, then paste the URL here. Example: 'https://www.kyero.com/en/spain-property-for-sale-0l55529'",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeDetails": {
                        "title": "Include property details",
                        "type": "boolean",
                        "description": "Visit each property page for full description, GPS coordinates, all features, and agent contact details. Slower per property but much richer.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max properties",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum properties to scrape. 0 = no limit.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Max pages",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum search result pages per URL. 0 = no limit.",
                        "default": 5
                    },
                    "requestDelay": {
                        "title": "Request delay (ms)",
                        "minimum": 200,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Delay between requests. 300-800ms recommended for Cloudflare.",
                        "default": 500
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Parallel detail page requests. Keep 6-10.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Spanish residential proxy REQUIRED — Kyero uses Cloudflare that geo-gates non-EU IPs. Preconfigured — don't change unless you have your own ES proxy.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "ES"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
